抽象：

不能处理的信息：暂时入栈。

能处理的信息：从栈里面选择信息，加工处理，并出栈。

一、括号匹配算法

左括号等待匹配，所以入栈等待匹配。

右边括号就要判断是否匹配，所以判断是否匹配并出栈。

左边：

1. 进栈等待匹配

右边括号匹配有以下情况:

1. 能够刚好匹配

2. 不能匹配

3. 左边括号用完了无法匹配

  bool isValid(string s) {
        for(auto i : s)
        {
            if(i == '(' || i == '{' || i == '[') 
            {
                left.push(i);
                continue;
            }

            if((i == ')' || i == ']' || i == '}') && !left.empty() && ispair(left.top(),i))
            {
                left.pop();
                continue;
            }

            if((i == ')' || i == ']' || i == '}') && left.empty()) return false;


            if((i == ')' || i == ']' || i == '}') && !ispair(left.top(),i)) return false;
        }
        return left.empty()?true:false;
    }

二、最小栈

常数时间拿到最小值的栈，普通栈，然后再来一个栈保存当前的最小值。

  MinStack() {
        mistack.push(_min);;
    }
    
    void push(int val) {
        opstack.push(val);

        _min = min(val,mistack.top());

        mistack.push(_min); 
    }

三、字符串解码

总结:对于栈暂时还不可以处理的信息存起来，可以处理时出栈处理。

例如第一个左括号前面是3"",入栈，第二次入栈a 2,入栈

第三次暂时的tmp是c，同时匹配到了右边括号，处理信息，a+2*c = acc,出栈

第四次匹配到了右括号继续计算 “”+3*acc = accaccacc，出栈

 string decodeString(string s) {
        for(auto i : s)
        {
            if(i>='a' && i <= 'z') res += i;
            if(i-'0' >=0 && i - '0' <= 9) nums+=i;
            if(i == '[' ) 
            {
                opstack.push({atoi(nums.c_str()),res});
                res = ""; 
                nums = "";   
            } 
            if(i == ']') {
                t_ans = cacul(res,opstack.top());
                opstack.pop();
                res = t_ans;
                nums = "";
            }
        }
        return res;
    }

四、每日温度

维护一个单调递减的单调栈，每当出现更大的气温则说明了之前的值已经找到了答案。

其实和之前的思路一样，不能处理的信息先入栈，能处理了就出栈处理。

比如73,不能处理，入栈

74，处理1，出栈73，入栈74

.....

stack<pair<int,int>> reduce_stack;

    vector<int> dailyTemperatures(vector<int>& temperatures) {
        vector<int> ans(temperatures.size(),0);
        reduce_stack.push({-1,INT_MAX});
        for(int i = 0 ; i < temperatures.size() ; i ++)
        {
            while(temperatures[i] > reduce_stack.top().second)
            {
                ans[reduce_stack.top().first] = i - reduce_stack.top().first;
                reduce_stack.pop();
            }
            reduce_stack.push({i,temperatures[i]});
        }

        return ans;    
    }