在一个数组中实现两个堆栈

Question

如何以一种方式在一个数组A [1..n]中实现两个堆栈，除非总数为no，否则堆栈都不会溢出。两个堆叠在一起的元素是n。 PUSH和POP应该在O（1）时间内运行吗？

这个算法出了什么问题？

//A[1...n], top1 is pointer pointing to top of stack1.

top1=-1;
top2=-1;

STACK-EMPTY(A)

1. if(top1==0 && top2==0)
2.    return 1
3. else
4.    return 0

STACK-FULL(A)

1.  if(top1==S1.length && top2==S1.length)
2.     return 1
3.  else if(top1==S1.length)
4.     return -1
5.  else  if(top2==S2.length)
6.     return -2
7.  else
8.     return 0

PUSH (A,x)
1.  if(!STACK-FULL())
2.      if(STACK-FULL()==-1)
3.          top2=top2+1
4.          S2[top2]=x
5.      else if(STACK-FULL()==-2)
6.          top1=top1+1
7.          S1[top1]=x
8.      else
9.          top1=top1+1   
10.         S1[top1]=x
11. else
12.    OVERFLOW

Answer 1

如果您尝试以这种方式实现它，两个堆栈都从数组的左侧开始。推和流行不会是O（1）。由于两个堆栈的元素将相互混合，因此您必须维护一个位置是属于stack1还是stack2，以及它是否为空（枚举）。

当你试图将一个元素插入到一个堆栈中时，你必须搜索一个空槽并将值放在那里（为此你可能会跳过其他堆栈中的元素）。

当你试图从一个堆栈中删除一个元素时，你必须将该元素标记为空，并找到属于相应堆栈的弹出元素左侧的元素，并使其成为堆栈的顶部

而且，对于检查完全或空，最好检查两个堆栈中的元素总和。

Push和Pop将是O（n）而不是你想要的O（1）。

如果您仍想在O（1）中实现push和pop以及从阵列同一侧的两个堆栈，我建议您保持堆栈的顶部，下一个自由索引和前一个/（下一个自由索引）元件。

如果元素已被占用，它将指向堆栈中的上一个索引，如果它是空闲的，则它将包含下一个自由索引。

Ex：free = 0; top1 = -1，top2 = -1 next [i] = i + 1 next [n-1] = -1最初

检查完全是刚满== -1

检查堆栈空白将是top1 == -1

将x插入前1

a[free] = x
next[free] = top1 // useful while poping
top1 = free
free = next[free]

从stack1弹出

temp = top1 // storing top since we have to make this index as free and point next of this index to previous free
top1 = next[top1] // setting previous element as top
next[temp] = free
free = temp

这个实现的缺点是我们正在使用O（n）额外内存

Answer 2

这也可以通过将偶数索引分配给Stack1并将奇数索引分配给Stack2来实现。通过使用动态数组大小实现，可以潜在地解决堆栈溢出问题。两个堆栈的Top1和top2将始终指向相应的偶数和奇数位置的索引。对于不同尺寸的纸叠，我们将在相应位置没有

使用python中的一个列表实现两个堆栈

#Idea将为Stack1设置o偶数索引，为Stack 2设置奇数索引

ImplementTwoStacks类：

def __init__(self):
    self.array = [None for count in range(2)]
    self.top1 = 0
    self.top2 = 1

def len_array(self):
    return len(self.array)

def pushStack1(self, item):
    if self.top1 == self.len_array() - 2:
        self.array = self.array + [None for count in range(10)]
    if self.top1 == 0:
        self.array[self.top1] = item
        self.top1 += 2
        return

    self.array[self.top1] = item
    self.top1 += 2
    return

def pushStack2(self, item):
    #all odd index
    if self.top2 == self.len_array() - 1:
        self.array = self.array.extend([1 for count in range(10)])

    if self.top2 ==1:
        self.array[self.top2] = item
        self.top2 += 2
        return

    self.array[self.top2] = item
    self.top2 += 2

    return

def popStack1(self):

    if self.top1 == 0:
        temp = self.array[self.top1]
        self.array[self.top1] = None
        return temp

    self.top1 -= 2
    temp = self.array[self.top1]
    self.array[self.top1] = None
    return temp

def popStack2(self):
    if self.top2 ==1:
        temp = self.array[self.top2]
        self.array[self.top2] = None
        return temp

    self.top2 -= 2
    temp = self.array[self.top2]
    self.array[self.top2] = None
    return temp


def display_stack1(self):

    for item in self.array[0:len(self.array):2]:
        if item:
            print(item, "", end= "->")

def display_stack2(self):
    for item in self.array[1:len(self.array):2]:
        if item:
            print(item, "", end="->")