1、两个栈实现一个队列

有三种思路:

思路一：将stack1作为存储空间，将stack2作为临时缓冲区，入队时，直接压入stac1，出队时，将stack1中的元素依次出栈压入stack2中，再将stack2的栈顶元素弹出，最后将stack2中的元素再倒回给stack1

思路二：入队时，判断stack1是否为空，如果stack1为空，则将stack2中的所有元素都倒入stack1中，再将元素直接压入stack1，否则，直接压入stack1中
出队时，判断stack2是否为空，如果stack2为空，则将stack1中的元素倒入stack2中，在将stack2的栈顶元素弹出，否则，直接弹出stack2的栈顶元素
思路三：入队时，直接压入stack1中出队时，判断stack2是否为空，如果stack2为空，则将stack1中的元素倒入stack2中，否则直接弹出stack2中的元素
思路一与思路二相比，如果是连续出栈操作或连续进栈操作，思路二比思路一好很多。思路三最好代码如下。

栈实现Q

# 两个栈实现一个队列
# 栈先近后
# 列表的append 和pop结合就是栈
class QueueWithTwoStack(object):

    def __init__(self):
        self._stack1 = []
        self._stack2 = []

    def pop(self):
        if self._stack2:
            return self._stack2.pop()
        elif not self._stack1:
            return None
        else:
            while self._stack1:
                self._stack2.append(self._stack1.pop())
        return self._stack2.pop()

    def push(self, x):
        self._stack1.append(x)


a = QueueWithTwoStack()

for i in range(5):
    a.push(i)
for i in range(5):
    print(a.pop())

2、两个队列实现一个栈

将queue1用作进栈出栈，queue2作为一个中转站

入栈时，直接压入queue1中

出栈时，先将queue1中的元素除最后一个元素外依次出队列，并压入队列queue2中，将留在queue1中的最后一个元素出队列即为出栈元素，最后还要把queue2中的元素再次压入queue1中
图示:

Q实现栈

实现代码如下：

# 两个队列实现一个栈
# 队列就是先进先出 使用列表的append() 和pop(0)实现
# 栈就是先进后出

class StackWithTwoQueue(object):
    def __init__(self):
        self._queue1 = []  #
        self._queue2 = []

    def push(self, x):
        self._queue1.append(x)

    def pop(self):
        if not self._queue1:
            return None
        while self._queue1:
            if self._queue1.__len__() == 1:
                m = self._queue1.pop()
                break
            else:
                self._queue2.append(self._queue1.pop(0))
        while self._queue2:
            self._queue1.append(self._queue2.pop(0))
        return m


b = StackWithTwoQueue()
n = 3

for i in range(n):
    b.push(i)
for i in range(n):
    print(b.pop())