155.最小栈-力扣（LeetCode）

55.最小栈-力扣（LeetCode）

👉155.最小栈-力扣（LeetCode）

题目描述：设计push、pop、top、getMin，函数，并且可以在时间复杂度为O(1)的情况下找出最小值
错误的思路：给定一个变量，来记录最小值，这种想法是错误的，我们应该要更全面的考虑问题。
当我们入栈{6，5，4，3，2，1}时，每次记录最小值的变量随着每次入栈而改变，当数据全部入栈，记录最小值的变量就为1，如果在不删除数据的情况下，可以以O（1）的时间复杂度找到最小值，但是如果删除出来一个栈顶的元素，则栈中的最小值也发生了改变，与记录最小值的变量不匹配。

正确题解

通过上面的错误思路，我们可以加以改进。
在每一次元素入栈时，记录当前栈中的最小值，存放在另一个栈中。
例如：{6，5，4，3，2，1}
当6入栈时，当前栈中的元素最小值为6；
当5入栈时，当前栈中的元素最小值为5；
当4入栈时，当前栈中的元素最小值为4；
当3入栈时，当前栈中的元素最小值为3；
当2入栈时，当前栈中的元素最小值为2；
当1入栈时，当前栈中的元素最小值为1；
把每次入栈时的最小元素存放在一个栈（min_stack）中来保存。
当删除栈顶的元素时，min_stack也随之删除栈顶元素，保证了栈中元素的最小值与min_stack对应，找栈中最小值时直接在min_stack中的栈顶拿。时间复杂度为O(1)，这种做法叫以空间换时间。

代码：

class MinStack {
public:
    /** initialize your data structure here. */
    MinStack() {}
    
    void push(int val) {
        st.push(val);
        if(min_stack.empty()||val<=min_stack.top())
        min_stack.push(val);
        else
        {
            min_stack.push(min_stack.top());
        }
    }
    
    void pop() {     
        st.pop();
        min_stack.pop();
    }
    
    int top() {
        return st.top();
    }
    
    int getMin() {
        return min_stack.top();
    }
    private:
        stack<int> st;
        stack<int> min_stack;
};

优化题解1

在上面的方法中，存在着空间浪费。
例如：{5，3，2，4，6，1}
在min_stack中也存放{5，3，2，2，2，1}，在入栈4，6时，也要在min_stack中存放2，形成了一定程度的空间浪费。
有什么好解决的方法吗？如果呢避免就好了。🧐
当入栈的元素比min_stack栈顶的元素大时，min_stack则不需要保存这时栈中的最小值。
只有入栈的元素比min_stack栈顶的元素小或者等于时，才需要保存这时栈中的最小值。
例如：{5，3，2，4，6，1}
1：5入栈时，当前最小值为5，min_stac保存5，这时min_stack中只要5：{5}
2：3入栈时，当前最小值为3，min_stac保存3，这时min_stack中只要5：{5，3}
3：2入栈时，当前最小值为2，min_stac保存2，这时min_stack中只要5：{5，3，2}
4：4入栈时，当前最小值为2，不需要保存这时的最小值，这时min_stack中只要5：{5，3，2}
5：6入栈时，当前最小值为2，不需要保存这时的最小值，这时min_stack中只要5：{5，3，2}
6：1入栈时，当前最小值为1，min_stac保存1，这时min_stack中只要5：{5，3，2，1}
在删除栈顶元素时，当栈顶元素与min_stack栈顶元素相同时，则min_stack栈顶元素也删除。不同时，min_stack栈顶元素不需要删除。

代码：

class MinStack {
public:
    /** initialize your data structure here. */

    MinStack() {}
    
    void push(int val) {
        st.push(val);
        if(min_stack.empty()||val<=min_stack.top())
        min_stack.push(val);
    }
    
    void pop() {
        if(st.top()==min_stack.top())
        {
            min_stack.pop();
        }
        st.pop();
    }
    
    int top() {
        return st.top();
    }
    
    int getMin() {
        return min_stack.top();
    }
    private:
    	stack<int> st;
    	stack<int> min_stack;
};

优化题解2

在优化题解1中还会存在浪费空间。
例如：{5，3，2，2，2，6，4，1，1，1}
用优化题解1中的方法：min_stack：{5，3，2，2，2，1，1，1}，出现了重复的2和1。
如果出现极端情况，出现了N个2，那么在min_stack中也要存入N个2，浪费了大量的空间。
有什么方法解决这个问题吗？🧐
计数方法：和计数排序一样的原理。
例如：{5，3，2，2，2，6，4，1，1，1}
用一个结构体来记录：

struct val_count
{
	int _val;//记录最小值
	int _count://记录次数
};

在min_stack：{{5，1}，{3，1}，{2，3}，{1，3}}——>前一个数字表示这个阶段的最小值，后面的数字表示这个阶段最小值出现的次数。

直到_count减到0，才删除min_stack的栈顶元素。

代码：

struct val_count
{
    int _val;
    int _count;
};
class MinStack {
public:
    /** initialize your data structure here. */
    
    MinStack() {}
    
    void push(int val) {
        st.push(val);
        if(min_stack.empty()||val<(min_stack.top()._val))
        {
           vat_count temp={val,1};
           min_stack.push(temp);
        }
        else
        {
            if(val==(min_stack.top()._val))
            min_stack.top()._count++;
        }
    }
    
    void pop() {
        if(st.top()==min_stack.top()._val)
        {
            min_stack.top()._count--;
            if(min_stack.top()._count==0)
            min_stack.pop();
        }
        st.pop();
    }
    
    int top() {
        return st.top();
    }
    
    int getMin() {
        return min_stack.top()._val;
    }

    private:
        stack<int> st;
        //stack<int> min_stack;
        stack<vat_count> min_stack;
};

---

到此结束啦