Python栈和队列--经典算法回顾

1.用栈实现队列

LeetCode：232. 用栈实现队列   简单

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

• push(x) -- 将一个元素放入队列的尾部。
• pop() -- 从队列首部移除元素。
• peek() -- 返回队列首部的元素。
• empty() -- 返回队列是否为空。

示例：

MyQueue queue = new MyQueue();
queue.push(1);
queue.push(2);  
queue.peek();  // 返回 1
queue.pop();   // 返回 1
queue.empty(); // 返回 false

注意：

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

思路1： 栈：先进后出 ；队列：先进先出

两个栈实现，A栈作为压栈push,B栈作为弹出栈pop;

push的时候，把结果压入A栈，并且判断B栈是否为空，如果为空，A中所有的元素移动到B栈。

pop的时候，判断A,B栈是否为空，如果同时为空，抛出异常，如果不同时为空，判断B栈是否有元素，如果没有，则将A栈中元素全部移动到B栈中，进行弹出。

代码1：

class MyQueue:

    def __init__(self):
        """
        Initialize your data structure here.
        栈先进后出
        """
        self.stack_one = [] # 压入栈
        self.stack_two = [] # 弹出栈

    def push(self, x: 'int') -> 'None':
        """
        Push element x to the back of queue.
        """
        
        self.stack_one.append(x)
        
        
        

    def pop(self) -> 'int':
        """
        Removes the element from in front of queue and returns that element.
        """
        if not self.stack_two: #弹出栈为空的时候把压入栈的所有元素放至弹出栈中
            while self.stack_one:
                self.stack_two.append(self.stack_one.pop())
        return self.stack_two.pop()

    def peek(self) -> 'int':
        """
        Get the front element.
        """
        
        if self.stack_two:
            return self.stack_two[-1]
        else:
            while self.stack_one:
                self.stack_two.append(self.stack_one.pop())
        return self.stack_two[-1]
        

    def empty(self) -> 'bool':
        """
        Returns whether the queue is empty.
        """
        if len(self.stack_one) == 0 and len(self.stack_two) == 0:
            return True
        return False

 

思路二：一个栈实现

#一个栈实现队列
class MyQueue2:
    def __init__(self):
        self.stack = []

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

    def pop(self):
        '''
        获取队头元素
        :return:
        '''
        return self.stack.pop(0)
    def peek(self):
        '''
        获取顶端的数字
        :return:
        '''
        return self.stack[0]
    def empty(self):
        return self.stack == []

 

 

2.用队列实现栈

 LeetCode ：225 用队列实现栈

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

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

注意:

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

思路：

      一个队列实现栈

from collections import deque


class MyStack:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.deque_n = deque()

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

    def pop(self) -> int:
        """
        Removes the element on top of the stack and returns that element.
        """
        return self.deque_n.pop()

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

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

obj = MyStack()
obj.push(1)
obj.push(2)
param_2 = obj.pop()
param_3 = obj.top()
param_4 = obj.empty()

两个队列实现栈：

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

入栈时，直接压入queue1中

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

class MyStack2:
    def __init__(self):
        self.queue_one = []
        self.queue_two = []

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

    def pop(self):
        one_len = len(self.queue_one)
        for i in range(one_len-1): #剩下最后一个
            self.queue_two.append(self.queue_one.pop(0))
        res = self.queue_one.pop()
        two_len = len(self.queue_two)
        for j in range(two_len):
            self.queue_one.append(self.queue_two.pop(0))
        return res

    def top(self):
        return self.queue_one[-1]

    def empty(self):
        return self.queue_one == []

 

3.最小栈

LeetCode：115 最小栈

设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。

• push(x) -- 将元素 x 推入栈中。
• pop() -- 删除栈顶的元素。
• top() -- 获取栈顶元素。
• getMin() -- 检索栈中的最小元素。

方法一：

#从一开始就把min值存储
class MinStack:

    def __init__(self):
       
        self.stack = []
        self.min = None

    def push(self, x):
       
        self.stack.append(x)
        if self.min == None or self.min > x:
            self.min = x

    def pop(self):
       
        popItem = self.stack.pop()
        if len(self.stack) == 0:
            self.min = None
            return popItem
        
        if popItem == self.min:
            self.min = self.stack[0]
            for i in self.stack:
                if i < self.min:
                    self.min = i
        return popItem

    def top(self):
       
        return self.stack[-1]

    def getMin(self):
       
        return self.min

方法二：

class MinStack:

    def __init__(self):
        """
        栈先进后出
        队列先进先出
        initialize your data structure here.
        别人好的代码：
        
        """
        self.stack = []
        

    def push(self, x: 'int') -> 'None':
        self.stack.append(x)
        

    def pop(self) -> 'None':
       
        
        self.stack.pop() # 这里用的list的pop
        

    def top(self) -> 'int':
        return self.stack[-1]

    def getMin(self) -> 'int':
        min_num = min(self.stack)
        return min_num