代码随想录算法训练营第十一天| LeetCode20 有效的括号、LeetCode1047 删除字符串中的所有相邻重复项、LeetCode150 逆波兰表达式

20.有效的括号

思路：利用栈的结构具备先进后出的特点，来判断是否有对应的括号，当输入(、{、[，的时候，向栈入存)、}、]，当输入)、}、]时，如果栈顶的元素与之不相同，返回false，如果与之相同，则将栈顶的元素推出，如果字符串还没有遍历完，输入)、}、]时，栈就为空了，说明多了右括号，返回false。如果遍历完整个字符串后，栈为空，返回true。

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

1047.删除字符串中的所有相邻重复项

思路：利用栈先进后出的特点，如果输入元素与栈顶元素相同，则弹出栈顶元素，否则向栈内输入元素，最后栈内留下的元素顺序是反的，需要定义一个新的字符串，翻转顺序后输出。

reverse();

class Solution {
public:
    string removeDuplicates(string s) {
        stack<char> s1;
        for(int i=0;i<s.size();i++)
        {   
            if(s1.empty() || s[i]!=s1.top())
            {
                s1.push(s[i]);
            }
            else
            {
                s1.pop();
            }
        }
        string result="";
        while(!s1.empty())
        {
            result.push_back(s1.top());
            s1.pop();
        }
        reverse(result.begin(),result.end());
        return result;
    }
};

如果利用字符串，直接push_back输入，每次输入判断尾端元素，此时字符串的顺序是正确的，遍历字符串后直接输出即可

class Solution {
public:
    string removeDuplicates(string s) {
        string result;
        for(int i=0;i<s.size();i++)
        {   
            if(result.empty() || s[i]!=result.back())
            {
                result.push_back(s[i]);
            }
            else
            {
                result.pop_back();
            }
        }
        return result;
    }
};

150.逆波兰表达式

思路：如果是数字，直接向栈内输入（需要把字符串改为整形），如果是数学符号，则对栈顶的前两个元素进行数学操作，然后将前两个元素弹出，将数学计算后的结果输入栈内。由于题目所给的逆波兰表达式都是合法的，不考虑不合法的情况。

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> s1;
        for(int i =0;i<tokens.size();i++)
        {
            int num1 = 0;
            int num2 = 0;
            if(tokens[i]=="+"||tokens[i]=="-"||tokens[i]=="*"||tokens[i]=="/")
            {
                num1 = s1.top();
                s1.pop();
                num2 = s1.top();
                s1.pop();
                if(tokens[i]=="+")
                {
                    s1.push(num1+num2);
                }
                else if(tokens[i]=="-")
                {
                    s1.push(num2-num1);
                }
                else if(tokens[i]=="*")
                {
                    s1.push(num2*num1);
                }
                else
                {
                    s1.push(num2/num1);
                }
            }
            else
            {
                s1.push(stoll(tokens[i]));
            }
        }
        return s1.top();
    }
};

收获：

1、复习reverse()函数，翻转。

2、要对字符串中的数字进行数字计算时，需要先把字符串转换成可以计算的整型或其他形式。

3、用栈来处理对称或者相邻元素的问题是比较简单的。