栈专题

栈专题

性质

栈就不用多说了，一种后进先出的数据结构，常见的应用有单调栈

例题

1. 有效的括号 https://leetcode.cn/problems/valid-parentheses/

• 思路很简单，碰到左括号就入栈，右括号就开始判断。关键是处理好不同情况的分类，注意最后要判断一下栈空不空，如果不空的话说明有落单的括号，要返回false

class Solution {
public:
    bool isValid(string s) {
        stack<char> stk;
        for(int i=0;i<s.size();i++){
            if(s[i]=='('||s[i]=='{'||s[i]=='[') stk.push(s[i]);
            else{
                if(!stk.empty()&&((s[i]==')'&&stk.top()=='(')||(s[i]=='}'&&stk.top()=='{')||(s[i]==']'&&stk.top()=='['))){
                    stk.pop();
                }else{
                    return false;
                }
            }
        }
        if(!stk.empty())return false;
        return true;
    }
};

2. 字符串解码 https://leetcode.cn/problems/decode-string/

• 开一个数字栈和string栈，数字栈用来存编码中的数字，string栈存左括号和编码的字符，碰到右括号就出栈开始解码。碰到这题也要注意考虑一些边界情况。

class Solution {
public:
    stack<int> num;
    stack<string> str;
    string decodeString(string s) {
        for(int i=0;i<s.size();i++){
            if(s[i]>='0'&&s[i]<='9'){
                int sum=0;
                while(s[i]>='0'&&s[i]<='9'){ //这里不需要判断i是否越界, 因为题目给的数据保证了数字一定不会在最后
                    sum=sum*10+s[i]-'0';
                    i++;
                }
                i--;
                num.push(sum);
            } 
            else{
                if(s[i]==']'){
                    int number=num.top();
                    num.pop();
                    string substr="";
                    while(str.top()[0]!='['){
                        substr=str.top()+substr; //注意由于栈的特性, 应该把栈顶元素加到前面
                        str.pop();
                    }
                    string final_str="";
                    for(int i=1;i<=number;i++) final_str+=substr;
                    str.pop();
                    str.push(final_str);
                }else{
                    if(s[i]=='['){ //如果是[,直接入栈
                        string substr(1,s[i]);
                        str.push(substr);
                    }else{ //如果是字母,要往后遍历,得到完整的字母string
                        string substr="";
                        while(i<s.size()&&s[i]>='a'&&s[i]<='z'){
                            substr=substr+s[i];
                            i++;
                        }
                        // cout<<substr<<endl;
                        str.push(substr);
                        i--;
                    }
                }
            }
        }
        string final_str="";
        while(str.size()){
            final_str=str.top()+final_str; //注意由于栈的特性, 应该把栈顶元素加到前面
            str.pop();
        }
        return final_str;
    }
};

3. 最小栈 https://leetcode.cn/problems/min-stack/

• 思路很简单，可以用辅助栈，记录每一个节点入栈时的最小值。

class MinStack { //实际上除了实现普通的栈, 还要对应地实现一个单调栈(单调递减)
public:
    vector<int> stk;
    vector<int> min_stk;
    MinStack() {
        min_stk.push_back(INT_MAX);
    }
    
    void push(int val) {
        stk.push_back(val);
        min_stk.push_back(min(min_stk[min_stk.size()-1],val));
    }
    
    void pop() {
        stk.pop_back();
        min_stk.pop_back();
    }
    
    int top() {
        return stk[stk.size()-1];
    }   
    
    int getMin() {
        return min_stk[min_stk.size()-1];
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(val);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

4. 每日温度 https://leetcode.cn/problems/daily-temperatures/

• 这题用到了很经典的单调栈
• 单调栈的基本思路：维护一个栈，栈中的元素是递减(or递增)的。以递减为例，每次要有新元素入栈的话，从栈顶元素开始，把所有小于当前元素的栈内元素出栈，最后把这个新元素入栈。

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        vector<int> res(temperatures.size());
        stack<pair<int,int>> stk; //单调栈, 存的都是还没确定res[i]的日子, 栈顶天数的温度是栈中最低的-->单调递减栈
        for(int i=0;i<temperatures.size();i++){
            if(stk.empty()){
                stk.push({i,temperatures[i]}); //{第几天,这天的温度}
            }
            else{
                while(!stk.empty()&&stk.top().second<temperatures[i]){ //栈中有比当前天气温度低的-->可以更新这些天气的res信息
                    auto t=stk.top();
                    stk.pop();
                    int day=t.first;
                    res[day]=i-day;
                }
                stk.push({i,temperatures[i]}); //出栈完所有比当前天气温度低的天气, 该比较和更新的都结束了, 因此可以把当前天气入栈, 用于后续比较
            }
        }
        return res;
    }
};