用两个栈模拟一个队列c++结论_数据结构与算法-栈和队列

栈

栈是一种先入后出，即 First In Last Out (FILO) 的线性结构。所包含的基本操作有：

• 入栈，即向栈内添加元素。s.push(x)
• 出栈，即弹出栈顶元素。s.pop()
• 访问栈顶，即获得栈顶元素：s.top()
• 判断栈是否为空：s.empty()
• 获得栈中元素的个数：s.size()

栈

队列

队列是一种先入先出，即 First In First Out (FIFO) 的线性结构。所包含的基本操作有：

• 入队：q.push(x)
• 出队：q.pop()
• 访问队首元素：q.front()
• 访问队尾元素：q.back()
• 判断队列空：q.empty()
• 访问队列中的元素个数：q.size()

队列

题目：用队列实现栈 (leetcode 225)

即，用先进先出的数据结构，实现后进先出的数据结构

- 思路: 用两个队列, 队列一 用于存储数据，队列 q2 用于辅助

- push()： 直接放入进队列一中。

- top()： 为了获得队列一的最后一个元素，将前 n-1 个元素都放入队列二，返回最后一个元素，再把最后一个元素放入队列二，交换队列一二，以还原。

- pop()：与top()类似，只不过不将队列一中的最后一个元素放入队列二，而是直接弹出。

class MyStack:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        # 队列q1存放数据
        self.q1 = queue.Queue()
        # 队列q2辅助
        self.q2 = queue.Queue()

    def push(self, x: int) -> None:
        """
        Push element x onto stack.
        """
        self.q1.put(x)

    def pop(self) -> int:
        """
        Removes the element on top of the stack and returns that element.
        """
        # 把队列q1中除最后一个元素, 都put进q2
        for _ in range(self.q1.qsize()-1):
            self.q2.put(self.q1.get())

        # 交换q1, q2
        self.q1, self.q2 = self.q2, self.q1

        return self.q2.get()

    def top(self) -> int:
        """
        Get the top element.
        """
        for _ in range(self.q1.qsize()-1):
            self.q2.put(self.q1.get())
        top_element = self.q1.get()
        self.q2.put(top_element)

        # 交换q1和q2
        self.q1, self.q2 = self.q2, self.q1

        assert self.q2.empty()
        return top_element

    def empty(self) -> bool:
        """
        Returns whether the stack is empty.
        """
        return self.q1.empty()

题目：用栈实现队列

• 思路: 使用两个栈实现队列
• push 操作：直接放入栈一
• pop 操作：
  • 如果两栈均为空，则直接返回
  • 如果栈二为空，将栈一的元素逐个压入栈二，并弹出栈二栈顶元素
  • 如果栈二中有元素，直接弹出栈二的栈顶元素
• peek 操作：
  • 如果两栈均为空，则直接返回
  • 如果栈二为空，将栈一的元素逐个压入栈二，并返回栈二栈顶元素
  • 如果栈二中有元素，直接返回栈二的栈顶元素
• empty 操作：
  • 判断两栈是否均为空栈

class MyQueue:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.stack_1 = []
        self.stack_2 = []

    def push(self, x: int) -> None:
        """
        Push element x to the back of queue.
        """
        # 栈一用于存储数据，数据直接 push 进栈一
        self.stack_1.append(x)

    def pop(self) -> int:
        """
        Removes the element from in front of queue and returns that element.
        """
        # 两个栈都为空，说明“队列”为空，直接返回
        if (not bool(self.stack_1)) and (not bool(self.stack_2)):
            return

        # 若栈二不为空，直接弹出栈二的栈顶元素
        if bool(self.stack_2):
            return self.stack_2.pop()

        # 栈二为空，将栈一元素倒入栈二
        else:
            for _ in range(len(self.stack_1)):
                self.stack_2.append(self.stack_1.pop())
            return self.stack_2.pop()

    def peek(self) -> int:
        """
        Get the front element.
        """
        if (not bool(self.stack_1)) and (not bool(self.stack_2)):
            return
        if bool(self.stack_2):
            return self.stack_2[-1]
        else:
            for _ in range(len(self.stack_1)):
                self.stack_2.append(self.stack_1.pop())
            return self.stack_2[-1]

    def empty(self) -> bool:
        """
        Returns whether the queue is empty.
        """
        return not (bool(self.stack_1) or bool(self.stack_2))