leetcode :155. 最小栈（python）

题目：来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/min-stack

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

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

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.getMin();   --> 返回 -2.

题解：

1、笨办法1

两个栈，一个存数据，一个放最小值，一个无序，一个有序：

代码如下

class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stack_=[]
        self.min_=[]

    def push(self, x: int) -> None:
        self.stack_.append(x)
        self.min_.append(x)
        self.min_.sort(reverse=True)
    def pop(self) -> None:
        self.min_.remove(self.stack_[-1])
        self.min_.sort(reverse=True)
        self.stack_.pop()
    def top(self) -> int:
        return self.stack_[-1]
    def getMin(self) -> int:
        return self.min_[-1]


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

注意：

1、min_因为已被排序所以pop时不能直接调用python  list中的pop，需要使用remove

2、原始stack_不能使用remove(),因为一旦含有两个相同值，remove将删除第一个，而不是栈要求的栈顶元素

3、sort()默认reverse=False为升序排列，此时求最小值需要更改至True

结果：

战胜了29.9%的用户。

很显然这个方法不够好。

2、既然调用了python的sort方法，直接最后一步sort求最小值不就好了？

import copy
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 getMin(self) -> int:
        min_=copy.deepcopy(self.stack_)
        min_.sort(reverse=True)
        return min_[-1]


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

很显然;

并不可以~

并且，在使用此方法时，关于python深拷贝、浅拷贝也是一个出错点：

当使用

min_=self.stack_
min_.sort(reverse=True)

对min_数组进行排序，也会改变stack_数组的原有顺序，copy和=赋值都属于浅拷贝，会改变原有拷贝对象内容。

因此此处使用deppcopy深拷贝。

3、最小栈方法

当使用两个栈，存放最小值的那个栈可以选择性存放，保证栈顶元素永远最小。

举个例子：

当分别输入1,2,3时，最小栈只存1，再输入0时，最小栈存入零，此时：

原始栈：1,2,3,0

最小栈：1,0

当原始栈pop后，最小栈pop，

则之后最小值一直为1.

代码如下：

class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stack_=[]
        self.min_stack=[]
    def push(self, x: int) -> None:
        self.stack_.append(x)
        if(len(self.min_stack)==0):
            self.min_stack.append(x)
        elif(x<=self.min_stack[-1]):
            self.min_stack.append(x)
    def pop(self) -> None:
        if self.stack_[-1]==self.min_stack[-1]:
            self.min_stack.pop()
        self.stack_.pop()
    def top(self) -> int:
        return self.stack_[-1]
    def getMin(self) -> int:
        return self.min_stack[-1]


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

测试结果：

战胜了98.88%的用户

才疏学浅，先到这里啦。