快乐的LeetCode --- 225. 用队列实现栈的三种解法

题目描述：

使用队列实现栈的下列操作：

push(x) – 元素 x 入栈
pop() – 移除栈顶元素
top()– 获取栈顶元素
empty() – 返回栈是否为空

注意:
你只能使用队列的基本操作-- 也就是 push to back,peek/pop from front,size, 和is empty 这些操作是合法的。
你所使用的语言也许不支持队列。 你可以使用list或者deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）。

---

解题思路1:

单队列解法：入栈反序操作

定义辅助队列 queue

push()：将元素入队，除新入队元素，将其他元素从队首取出，再从队尾入队（完成反序）。此时队首元素即为新入队元素
pop()：queue 首个元素出队
top()： 获取 queue 首个元素
empty()：判断 queue 长度
此方法入栈时间复杂度为 O(n)，出栈时间复杂度为 O(1

---

代码1：

class MyStack:

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

    def push(self, x: int) -> None:
        """
        Push element x onto stack.
        """
        self.queue.append(x)
        # 队列反序
        length = len(self.queue)
        for i in range(length - 1):
            first = self.queue[0]
            del self.queue[0]
            self.queue.append(first)

    def pop(self) -> int:
        """
        Removes the element on top of the stack and returns that element.
        """
        target = self.queue[0]
        del self.queue[0]
        return target

    def top(self) -> int:
        """
        Get the top element.
        """
        return self.queue[0]

    def empty(self) -> bool:
        """
        Returns whether the stack is empty.
        """
        return len(self.queue) == 0

# Your MyStack object will be instantiated and called as such:
# obj = MyStack()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.top()
# param_4 = obj.empty()

---

解题思路2:

双队列解法：出栈时调整

定义两个辅助队列 queue1 与 queue2，使用一个变量 top_element 记录栈顶元素。

push()：将元素入队 queue1
pop()：将 queue1 内所有元素全部出队，除最后一个元素外，其余入队 queue2，而后删除最后一个元素并返回
更新 top_element
调换 queue1 与 queue2
top()：返回 top_elenemt
empty()：判断 queue1 的长度

此方法入栈时间复杂度为O(1)，出栈时间复杂度为 O(n)。

---

代码2：

class MyStack:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.queue1 = []
        self.queue2 = []
        self.top_element = 0
        
    def push(self, x: int) -> None:
        """
        Push element x onto stack.
        """
        self.queue1.append(x)
        self.top_element = x

    def pop(self) -> int:
        """
        Removes the element on top of the stack and returns that element.
        """
        # 把 queue1 里的元素取出，留下一个，其余塞入 queue2 中
        length1 = len(self.queue1)
        for i in range(length1 - 1):
            item = self.queue1[0]
            del self.queue1[0]
            self.queue2.append(item)
        self.top = item
        target = self.queue1[0]
        del self.queue1[0]
        # 交换 queue1 与 queue2
        self.queue1 = self.queue2
        self.queue2 = []
        return target

    def top(self) -> int:
        """
        Get the top element.
        """
        return self.top_element

    def empty(self) -> bool:
        """
        Returns whether the stack is empty.
        """
        return len(self.queue1) == 0

# Your MyStack object will be instantiated and called as such:
# obj = MyStack()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.top()
# param_4 = obj.empty()

---

解题思路3:

双队列解二：入栈时调整

定义两个辅助队列 queue1 与 queue2，使用一个变量 top_element 记录栈顶元素。

push(): 将元素入队 queue2，此时 queue2 中的首个元素为栈顶元素
更新 top_element
此时若 queue1 不为空，则让 queue1 中的元素逐个出队并加入 queue2中
pop(): queue1 首个元素出队，更新 top_element
top(): 返回 top_element
empty(): 判断 queue1 长度

此方法入栈时间复杂度为 O(n)，出栈时间复杂度为O(1)。

---

代码3：

class MyStack:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.queue1 = []
        self.queue2 = []
        self.top_element = 0

    def push(self, x: int) -> None:
        """
        Push element x onto stack.
        """
        # 更新栈顶元素
        self.top_element = x
        # 加入 queue2 中
        self.queue2.append(x)
        if not self.empty():
            # 如果 queue1 不为空，取出元素并加入 queue2
            length1 = len(self.queue1)
            for i in range(length1):
                self.queue2.append(self.queue1[0])
                del self.queue1[0]
        # 交换
        self.queue1 = self.queue2
        self.queue2 = []

    def pop(self) -> int:
        """
        Removes the element on top of the stack and returns that element.
        """
        target = self.queue1[0]
        del self.queue1[0]
        # 更新 top_element
        if not self.empty():
            self.top_element = self.queue1[0]
        return target

    def top(self) -> int:
        """
        Get the top element.
        """
        return self.top_element

    def empty(self) -> bool:
        """
        Returns whether the stack is empty.
        """
        return len(self.queue1) == 0

# Your MyStack object will be instantiated and called as such:
# obj = MyStack()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.top()
# param_4 = obj.empty()

---

转载于:
用队列实现栈的三种解法（Python/Go）