用两个栈实现队列 Python

Question

我最近在研究一些编程面试的问题。我在想，如果要用两个栈来实现一个队列，应该怎么做呢？我对Python不是特别熟悉，所以需要尽可能多的帮助。

比如说，像入队、出队和查看队首这些功能。

Answer 1

Stack1, Stack2.

Enqueue:
Push el into stack1.

Dequeue:
While (!empty(Stack1))
   el = Pop from stack1
   Push el into stack2

returnEl = Pop from Stack2

While (!empty(Stack2))
   el = Pop from stack2
   Push el into stack1

return returnEl

这是一种用伪代码实现算法的方法，知道基本的语法后，用Python实现应该不难。

Answer 2

首先，创建一个栈对象。然后用两个栈来创建一个队列。因为栈是后进先出（LIFO），而队列是先进先出（FIFO），所以你需要把所有的物品放到“输入栈”里，然后再把它们弹出到输出中。

class Stack:

    def __init__(self):
        self.items = []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def size(self):
        return len(self.items)

    def is_empty(self):
        return self.items == []

class Queue2Stacks(object):

    def __init__(self):

        # Two Stacks
        self.in_stack = Stack()
        self.out_stack = Stack()

    def enqueue(self, item):
        self.in_stack.push(item)

    def dequeue(self):

        if self.out_stack.is_empty:
            while self.in_stack.size()>0:
                self.out_stack.push(self.in_stack.pop())
        return self.out_stack.items.pop()

#driver code
q = Queue2Stacks()
for i in range(5):
    q.enqueue(i)
for i in range(5):
    print(q.dequeue(i))

这样你会得到0,1,2,3,4

Answer 3

在编程中，有时候我们需要把一些数据从一个地方转移到另一个地方。这就像把水从一个杯子倒到另一个杯子一样。我们需要确保水不会洒出来，也就是要保证数据的完整性。

为了做到这一点，程序员们会使用一些工具和方法来帮助他们完成这个任务。比如，他们可能会用一个叫做“函数”的东西，来把数据从一个地方拿出来，然后再放到另一个地方。函数就像是一个小机器，输入一些东西，它就会给你输出一些东西。

在这个过程中，程序员还需要考虑到数据的格式，就像不同的杯子可能有不同的形状，水倒进去可能会有不同的效果一样。确保数据格式正确，可以避免很多麻烦。

总之，数据的转移就像是一个简单的倒水过程，但在编程中，我们需要用一些工具和方法来确保这个过程顺利进行。

class Stack:

    def __init__(self):
        self.elements = []

    def push(self, item):
        self.elements.append(item)

    def pop(self):
        return self.elements.pop()

    def size(self):
        return len(self.elements)

    def is_empty(self):
        return self.size() == 0


class CreatingQueueWithTwoStacks:

    def __init__(self):
        self.stack_1 = Stack()
        self.stack_2 = Stack()

    def enqueue(self, item):
        self.stack_1.push(item)

    def dequeue(self):
        if not self.stack_1.is_empty():
            while self.stack_1.size() > 0:
                self.stack_2.push(self.stack_1.pop())
            res = self.stack_2.pop()
            while self.stack_2.size() > 0:
                self.stack_1.push(self.stack_2.pop())
            return res

if __name__ == '__main__':
    q = CreatingQueueWithTwoStacks()
    q.enqueue(1)
    q.enqueue(2)
    q.enqueue(3)
    a = q.dequeue()
    print(a)
    b = q.dequeue()
    print(b)
    c = q.dequeue()
    print(c)
    d = q.dequeue()
    print(d)
    q.enqueue(5)
    q.enqueue(6)
    print(q.dequeue())

Answer 4

class MyQueue(object):
    def __init__(self):
        self.first = []
        self.second = []

    def peek(self):
        if not self.second:
            while self.first:
                self.second.append(self.first.pop());
        return self.second[len(self.second)-1];


    def pop(self):
        if not self.second:
            while self.first:
                self.second.append(self.first.pop());
        return self.second.pop();

    def put(self, value):
        self.first.append(value);


queue = MyQueue()
t = int(raw_input())
for line in xrange(t):
    values = map(int, raw_input().split())

    if values[0] == 1:
        queue.put(values[1])        
    elif values[0] == 2:
        queue.pop()
    else:
        print queue.peek()

当然可以！请把你想要翻译的内容发给我，我会帮你把它变得简单易懂。

Answer 5

class Queue(object):
    def __init__(self):
        self.instack=[]
        self.outstack=[]
    def enqueue(self,element):
        self.instack.append(element)
    def dequeue(self):
        if not self.outstack:
            while self.instack:
                self.outstack.append(self.instack.pop())
        return self.outstack.pop()
q=Queue()
for i in range(10):
    q.enqueue(i)
for i in xrange(10):
    print q.dequeue(),

这段代码的作用是……

首先，它会……

接下来，它会……

最后，代码会……

这样做的好处是……

总的来说，这段代码帮助我们……

如果你有任何疑问，可以参考……

希望这能帮助你更好地理解！