【LeetCode】stack容器的使用例题

目录

 一、最小栈

二、栈的压入、弹出序列

三、逆波兰表达式求值

---

 一、最小栈

题目地址：

155. 最小栈 - 力扣（LeetCode）

对于该题我们可以建立两个stack，一个stack（_st）用来存储要存储的元素，另一个stack（_min）用来存储前一个stack中最小的元素。在_st入栈时，另一个_min判断入栈的元素是否为_st中所有元素的最小值，如果是就将该元素入栈到_min中，如果不是就将_min中的栈顶元素再次入栈到_min中。当_st出栈时，_min也跟着出栈，这样一来_st和_min的元素始终保持相等，且_min的栈顶元素永远是_st当前状态中的最小元素的值：

class MinStack {
public:

    MinStack()
    {}
    
    void push(int val) {
        if(_st.empty()||val<_min.top())
            _min.push(val);
        else
            _min.push(_min.top());
        _st.push(val);
    }
    
    void pop() {
        _st.pop();
        _min.pop();
    }
    
    int top() {
        return _st.top();
    }
    
    int getMin() {
        return _min.top();
    }
private:
    stack<int> _min;
    stack<int> _st;
};

但是上述思路中，_min有点浪费空间，我们不必每次_st入栈时都要将_min入栈一个最小元素：如果_st入栈时，入栈的元素大于_st中的最小值，我们可以不用将_min再入栈一个最小元素；在_st出栈时，如果出栈的元素不是_st中的最小值，我们也不必将_min出栈。如此一来，_min的元素始终只保存_st历史入栈时的最小值，且_min的栈顶元素永远是_st当前状态中的最小元素的值：

class MinStack {
public:

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

但是我们还要考虑一个极端情况，如果_st入栈时都是同一个元素呢？我们上面的优化不就不起作用了嘛

对于这种情况，我们可以利用计数的原理再自定义一个类型（Data），这个类型中有两个元素：一个是当前_st中最小元素的值（_val），另一个是记录_st已经连续入栈了多少个这个值（_count）。然后在_min中存储这个类型。

如果_st入栈时，入栈的元素小于_st中的最小值，我们将_min入栈一个Data，这个Data中_val为当前入栈元素，_count置为1；入栈的元素等于_st中的最小值，我们直接将_min的栈顶元素的Data的_count++；入栈的元素大于_st中的最小值，_min不做变化。

在_st出栈时，如果出栈的元素不是_st中的最小值，我们也不必将_min出栈；如果出栈元素是_st中的最小值，我们可以直接将min的栈顶元素的_count--，但如果_count等于1就说明该元素在_st中只剩最后一个了，直接将_min的栈顶元素pop即可。

class Data {
public:
    Data(int val,int count)
        :_val(val),
        _count(count)
    {}

    int _val;
    int _count;
};

class MinStack {
public:

    MinStack()
    {}

    void push(int val) {
        if (_st.empty() || val < _min.top()._val)
            _min.push(Data(val, 1));
        else if (val == _min.top()._val)
            ++_min.top()._count;
        _st.push(val);
    }

    void pop() {
        if (_st.top() == _min.top()._val)
        {
            if (_min.top()._count == 1)
                _min.pop();
            else
                --_min.top()._count;
        }
        _st.pop();
    }

    int top() {
        return _st.top();
    }

    int getMin() {
        return _min.top()._val;
    }

private:
    stack<int> _st;
    stack<Data> _min;
};

二、栈的压入、弹出序列

题目地址：

栈的压入、弹出序列_牛客题霸_牛客网 (nowcoder.com)

对于这一题我们可以使用一个栈模拟它的出栈和入栈，如果题目所给的出栈和入栈顺序可以匹配的上，最终这个栈就为空。

具体模拟过程为：我们在栈中没有元素的时候按所给的入栈元素顺序，先入一个元素进来，再拿出栈顺序的元素来对比栈顶元素：如果不相等，就继续按入栈顺序再压入一个元素，继续和出栈元素进行匹配；如果相等，就将栈顶元素出栈，拿下一个栈顶元素（如果栈空就压入下一个出栈元素）和下一个出栈的元素进行对比······

以此类推，如果能匹配成功，最终栈为空：

class Solution {
public:

    bool IsPopOrder(vector<int>& pushV, vector<int>& popV) {
        size_t num_push=0,num_pop=0;
        stack<int> _st;
        _st.push(pushV[num_push++]);
        for(;num_pop<popV.size();)
        {
            if(_st.empty() || popV[num_pop]!=_st.top())
            {
                _st.push(pushV[num_push++]);
            }
            else {
                _st.pop();
                ++num_pop;
            }
        }
        return _st.empty();
    }
};

 

三、逆波兰表达式求值

题目地址：

 150. 逆波兰表达式求值

对于该题我们可以使用一个栈来存储整数，先遍历传入的字符串，如果发现遍历到的字符串是个整数就将该值入栈，如果遍历到的是操作符（+-*/）就拿出栈顶的两个元素进行相对应的运算（运算 时要注意数据的左右所在位置），再将运算结果压入栈中。直到最后栈中的元素就是最终值：

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> val;
        for(auto& str:tokens)//这里使用&可以减少拷贝
        {
            if(str=="+"||str=="-"||str=="*"||str=="/")
            {   
                int right=val.top();
                val.pop();
                int left=val.top();
                val.pop();
                switch(str[0])
                {
                    case '+':
                        val.push(left+right);
                        break;
                    case '-':
                        val.push(left-right);
                        break;
                    case '*':
                        val.push(left*right);
                        break;
                    case '/':
                        val.push(left/right);
                        break;
                }
            }
            else
            {
                val.push(stoi(str));
            }
        }
        return val.top();
    }
};