leetccode栈与队列

1. 用两个栈实现队列（剑指offer09）

难度：简单

题目：

用两个栈实现一个队列。实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

例如：

输入：
["CQueue","appendTail","deleteHead","deleteHead"]
[[],[3],[],[]]
输出：[null,null,3,-1]

思路：用两个栈实现队列，栈是先进后出，而队列要求先进先出，用第一个栈负责接收输入，第二个栈负责反转第一个栈的内容输出。每次要输出时先检查第二个栈是否为空，如果是空的话就把第一个栈的全部内容反转到第二个栈再输出栈顶。

代码：

class CQueue:

    def __init__(self):
        self.stack1 = [] 
        self.stack2 = [] 

    def appendTail(self, value: int) -> None:
        self.stack1.append(value)
        return


    def deleteHead(self) -> int:
        if not self.stack2:
            while self.stack1:
                self.stack2.append(self.stack1.pop())
            if not self.stack2:
                return -1
            else:
                return  self.stack2.pop()
        else:
            return self.stack2.pop()
        return -1

时间复杂度：O(n)，最坏情况下进行一个弹出操作要移动n个元素

空间复杂度：O(n)，使用了额外的一个栈

2. 包含min函数的栈（剑指offer30）

难度：简单

题目：

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

 思路：

用python的列表直接实现栈的功能

代码：

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()

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

    def min(self) -> int:
        return min(self.stack)

直接实现时间复杂度很高，设法将min函数的时间复杂度降到O(1)

通过设置一个辅助栈，保存原始栈的非严格递减的元素值

class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stackA, self.stackB = [], []


    def push(self, x: int) -> None:
        self.stackA.append(x)
        if not self.stackB or x <= self.stackB[-1]:
            self.stackB.append(x)


    def pop(self) -> None:
        if self.stackA.pop() == self.stackB[-1]:
            self.stackB.pop()

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

    def min(self) -> int:
        return self.stackB[-1]

这样还是太慢，设计一个保存差值的栈，每次入栈时，如果比栈最小值大，则保存其差值，否则保存当前差值并更新栈最小值。弹出或者取栈顶元素时，若当前栈顶元素小于零，则表示当前栈顶元素改变了栈最小元素，需要输出栈最小元素，pop还需要更新栈最小元素（栈顶元素就是当前栈最小元素与之前栈最小的差值），否则就直接输出栈顶元素与栈最小值的和。

class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stack = []
        self.minv = -inf


    def push(self, x: int) -> None:
        if not self.stack:
            self.stack.append(0)
            self.minv = x
        else:
            self.stack.append(x-self.minv)
            self.minv = min(x,self.minv)


    def pop(self) -> None:
        pop = self.stack.pop()
        if pop < 0:#说明当前弹出栈顶元素是新加入最小元素
            self.minv = self.minv - pop#则pop后的最小值应当是当前最小值减掉弹出值（差值）


    def top(self) -> int:
        if self.stack[-1] < 0:
            return self.minv
        else:
            return self.stack[-1] + self.minv

    def min(self) -> int:
        return self.minv