【Day 11】 | 20. 有效的括号、1047. 删除字符串中的所有相邻重复项、150. 逆波兰表达式求值

20. 有效的括号

题目链接：20.有效的括号

卡尔文解

解题思路重点：

1. 第一种情况，字符串里左方向的括号多余了 ，所以不匹配。
   

2. 第二种情况，括号没有多余，但是 括号的类型没有匹配上。
   

3. 第三种情况，字符串里右方向的括号多余了，所以不匹配。
   
   我们的代码只要覆盖了这三种不匹配的情况，就不会出问题，可以看出 动手之前分析好题目的重要性。
   

代码实现：

class Solution {
public:
    bool isValid(string s) {
        
        stack<char> stk;
        int size = s.size();

        if ( (size % 2 ) != 0 ) return false;

        // Totally 3 scenarios:
        // 1. More left braces.
        // 2. equal braces but not matched.
        // 3. More right braces.
        
        for ( int idx = 0; idx < size; idx++ ){
            
            if ( s[ idx ] == '(' )
                stk.push( ')' );
            
            else if ( s[ idx ] == '[')
                stk.push( ']' );
            
            else if ( s[ idx ] == '{')
                stk.push( '}' );
            else if ( stk.empty() || ( s[ idx ] != stk.top()) )
                return false;
            else 
                stk.pop();
        }

        return stk.empty();

    }
};

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

题目链接：1047.删除字符串中的所有相邻重复项

卡尔文解

解题思路及注意事项：

本题要删除相邻相同元素，相对于20. 有效的括号 (opens new window)来说其实也是匹配问题，20. 有效的括号 是匹配左右括号，本题是匹配相邻元素，最后都是做消除的操作。

本题也是用栈来解决的经典题目。

那么栈里应该放的是什么元素呢？

我们在删除相邻重复项的时候，其实就是要知道当前遍历的这个元素，我们在前一位是不是遍历过一样数值的元素，那么如何记录前面遍历过的元素呢？

所以就是用栈来存放，那么栈的目的，就是存放遍历过的元素，当遍历当前的这个元素的时候，去栈里看一下我们是不是遍历过相同数值的相邻元素。

然后再去做对应的消除操作。 如动画所示：

代码实现：

class Solution {
public:

    // Use a string instead of stack , will output result accordingly.
    //           Use a String to simulate a stack
    //   Tail ------------------> Head
    //   back      a b c d        front
    string removeDuplicates(string s) {
        string result;

        for ( char c: s ){
            
            // A or B 
            if ( s.empty() || ( c != result.back()) )
                result.push_back( c );
            // Not ( A or B ) = ( !A && !B )
            // means ( result is not empty && c equals result back char  )
            else 
                result.pop_back();

        }

        return result;
    }
};

150. 逆波兰表达式求值

题目链接：150.逆波兰表达式求值

卡尔文解

解题思路及注意事项：

在上一篇文章中1047.删除字符串中的所有相邻重复项 (opens new window)提到了 递归就是用栈来实现的。
所以栈与递归之间在某种程度上是可以转换的！ 这一点我们在后续讲解二叉树的时候，会更详细的讲解到。
那么来看一下本题，其实逆波兰表达式相当于是二叉树中的后序遍历。 大家可以把运算符作为中间节点，按照后序遍历的规则画出一个二叉树。

但我们没有必要从二叉树的角度去解决这个问题，只要知道逆波兰表达式是用后序遍历的方式把二叉树序列化了，就可以了。
在进一步看，本题中每一个子表达式要得出一个结果，然后拿这个结果再进行运算，那么这岂不就是一个相邻字符串消除的过程，和1047.删除字符串中的所有相邻重复项 (opens new window)中的对对碰游戏是不是就非常像了。

代码实现：

class Solution {
public:
    int evalRPN(vector<string>& tokens) {

        stack<long long> stk;

        for ( auto item : tokens ){

            cout << "item = " << item << endl;

            if (( item == "+") || 
                ( item == "-") ||
                ( item == "*") ||
                ( item == "/") ){

                long long op1 = stk.top(); stk.pop();
                long long op2 = stk.top(); stk.pop();

                if ( item == "+" ) stk.push( op2 + op1 );
                if ( item == "-" ) stk.push( op2 - op1 );
                if ( item == "*" ) stk.push( op2 * op1 );
                if ( item == "/" ) stk.push( op2 / op1 );
            }
            else{
                stk.push( stoll( item ));
            }
        }
        return( stk.top());
    }
};