【代码随想录37期】Day11 有效的括号、删除字符串中的所有相邻重复项、逆波兰表达式求值

有效的括号

20. 有效的括号 - 力扣（LeetCode）

v1.0:比较憨憨，括号匹配不是直接==..
class Solution {
public:
    bool isValid(string s) {
        stack<int> stk;
        for(auto c:s){
            if(!stk.empty()&&stk.top()=='('&&c==')')
            {
                stk.pop();
            }
            else if(!stk.empty()&&stk.top()=='{'&&c=='}')
            {
                stk.pop();
            }
            else if(!stk.empty()&&stk.top()=='['&&c==']')
            {
                stk.pop();
            }
            else
            {
                stk.push(c);
            }
        }
        return stk.empty();

    }
};

v2.0:这样直接push要匹配的确实也挺聪明
class Solution {
public:
    bool isValid(string s) {
        stack<int> stk;
        for(auto c:s){
            if(c=='{')
            {
                stk.push('}');
            }
            else if(c=='(')
            {
                stk.push(')');
            }
            else if(c=='[')
            {
                stk.push(']');
            }
            else if(!stk.empty()&&c==stk.top())
            {
                stk.pop();
            }
            else{
                return false;
            }
        }
        return stk.empty();

    }
};

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

1047. 删除字符串中的所有相邻重复项 - 力扣（LeetCode）

代码随想录

v1.0:先用一个栈来删除连续项，然后再用一个栈把顺序倒过来，再把第二个栈的数据放到string里面返回
时间空间都比较拉
class Solution {
public:
    string removeDuplicates(string s) {
        stack<int> stk;
        for(int i = 0; i<s.size();i++)
        {
            if(!stk.empty()&&stk.top()==s[i]){
                stk.pop();
            }
            else
            {
                stk.push(s[i]);
            }
        }
        stack<int> stk2;
        while(!stk.empty())
        {
            stk2.push(stk.top());
            stk.pop();
        }
        string result;
        while(!stk2.empty())
        {
            result.push_back(stk2.top());
            stk2.pop();
        }
        return result;

    }
};

v2.0:可以用string的reverse来倒转，这样少声明一个栈
class Solution {
public:
    string removeDuplicates(string s) {
        stack<int> stk;
        for(int i = 0; i<s.size();i++)
        {
            if(!stk.empty()&&stk.top()==s[i]){
                stk.pop();
            }
            else
            {
                stk.push(s[i]);
            }
        }
        string result;
        while(!stk.empty())
        {
            result.push_back(stk.top());
            stk.pop();
        }
        reverse(result.begin(), result.end());
        return result;

    }
};

v3.0:直接用string当栈就行，避免声明新的栈，牛

class Solution {
public:
    string removeDuplicates(string s) {
        string result;
        for(auto c:s)
        {
            if(result.empty()||c!=result.back())
            {   
                result.push_back(c);
            }
            else
            {
                result.pop_back();
            }
        }
        return result;

    }
};

逆波兰表达式求值

代码随想录

150. 逆波兰表达式求值 - 力扣（LeetCode）

逆波兰式（Reverse Polish Notation，RPN，或逆波兰记法），也叫后缀表达式（将运算符写在操作数之后）

(a+b)c-(a+b)/e的后缀表达式为：
(a+b)c-(a+b)/e
→((a+b)c)((a+b)/e)-
→((a+b)c)((a+b)e/)-
→(ab+c)(ab+e/)-
→ab+cab+e/-

出现原因：对计算机而言中序表达式是非常复杂的结构。相对的，逆波兰式在计算机看来却是比较简单易懂的结构。因为计算机普遍采用的内存结构是栈式结构，它执行先进后出的顺序。

新建一个表达式,如果当前字符为变量或者为数字，则压栈，如果是运算符，则将栈顶两个元素弹出作相应运算，结果再入栈，最后当表达式扫描完后，栈里的就是结果。

(a+b)c的逆波兰式为ab+c，假设计算机把ab+c按从左到右的顺序压入栈中，并且按照遇到运算符就把栈顶两个元素出栈，执行运算，得到的结果再入栈的原则来进行处理，那么ab+c的执行结果如下：

1）a入栈（0位置）

2）b入栈（1位置）

3）遇到运算符“+”，将a和b出栈，执行a+b的操作，得到结果d=a+b，再将d入栈（0位置）

4）c入栈（1位置）

5）遇到运算符“”，将d和c出栈，执行dc的操作，得到结果e，再将e入栈（0位置）

经过以上运算，计算机就可以得到(a+b)*c的运算结果e了。

v1.0:其实并不难   主要是string向整数转换：stoll不知道，这下学会了，再一个就是明明可以用char，却用的string
class Solution {
public:
    stack<long long> stk;

    void calculate(string calSymbol)
    {   
        long long num1 = 0, num2 = 0;
        if(!stk.empty())
        {
            num2 = stk.top();
            stk.pop();
            num1 = stk.top();
            stk.pop();
        }
        if(calSymbol=="+")
        {
            stk.push(num1+num2);
        }
        else if(calSymbol=="-")
        {
            stk.push(num1-num2);
        }
        else if(calSymbol=="*")
        {
            stk.push(num1*num2);
        }
        else if(calSymbol=="/")
        {
            stk.push(num1/num2);
        }
    }

    int evalRPN(vector<string>& tokens) {
        
        for(auto s:tokens)
        {
            if(s=="+"||s=="-"||s=="*"||s=="/")
            {
                calculate(s);
            }
            else{
                stk.push(stoll(s));
            }
        }
        return stk.top();
    }
};