代码随想录：day11

使用C++语言

栈与队列part02

有效的括号
题意：判断字符串是否是有效括号的字符串，有效括号需满足：
1.左括号与相同的右括号匹配，并且每个右括号有对应的左括号
做法：利用栈的先进后出的特性， 括号如果以最里面的匹配括号分割，那么就符合栈的特性。
重点是遇见一个右括号就弹出栈， 左括号就压入栈， 遍历完字符串后，如果栈为空就是已经匹配上，不染就不是有效的括号。
核心代码

  for(auto it : s)
        {
            if(it == '(' || it == '{' || it == '[' )
            {
                st.push(it);
            }
            else{  // 要处理前面匹配成功和不能直接返回，而是要继续匹配直到遍历完数组或者，不能匹配的情况出现。
                if(st.empty())
                {
                    return false ; 
                }
                char t = st.top() ;
                cout<<t   ; 
                switch(t)
                {
                    case '('  :  
                    if( it != ')' ) // 只有在符合要求时才会进行下面的语句
                     return false   ; 
                     break; 
                    case '[' : 
                    if(it != ']')  
                    return false  ;
                    break ; 
                    case  '{' : 
                    if(it != '}') 
                    return false ; 
                    break ; 
                }         
                st.pop() ; 
            }
        }

全部代码

class Solution {
public:
    bool isValid(string s) {
        stack<char> st ;
        for(auto it : s)
        {
            if(it == '(' || it == '{' || it == '[' )
            {
                st.push(it);
            }
            else{  // 要处理前面匹配成功和不能直接返回，而是要继续匹配直到遍历完数组或者，不能匹配的情况出现。
                if(st.empty())
                {
                    return false ; 
                }
                char t = st.top() ;
                cout<<t   ; 
                switch(t)
                {
                    case '('  :  
                    if( it != ')' ) // 只有在符合要求时才会进行下面的语句
                     return false   ; 
                     break; 
                    case '[' : 
                    if(it != ']')  
                    return false  ;
                    break ; 
                    case  '{' : 
                    if(it != '}') 
                    return false ; 
                    break ; 
                }         
                st.pop() ; 
            }
        }
        if(st.empty())
        {
            return true  ;
        }

         return false ;
    }
};

删除字符串中的所有相邻重复项
不是一般的字符串去重， 而是针对栈的字符串去重。
实例：输入：“abbaca”
输出：“ca”

思路：遍历字符串，如果当前遍历元素与栈顶相同，栈顶出栈，如果不同就入栈。最后剩下栈的元素就是不同的元素。直接输出
核心代码

        for(auto it : s)
        {
            if(st.empty() || st.top() != it)
            {
                st.push(it) ;
            }
            else if(st.top() == it)
            {
                st.pop() ;

            }
        }

全部代码

class Solution {
public:
    string removeDuplicates(string s) {
        stack<char> st ;
        for(auto it : s)
        {
            if(st.empty() || st.top() != it)
            {
                st.push(it) ;
            }
            else if(st.top() == it)
            {
                st.pop() ;

            }
        }
        vector<char> tmp ;
        string res ;  
        if(st.empty())
        {
            return res  ;
        }

        // int size_ = st.size() ;
        while(!st.empty())
        {
            char t   ; 
             t = st.top() ; 
        tmp.push_back(t) ;
        st.pop() ;
        }
        for(int it = tmp.size()- 1  ;  it >= 0 ; --it)
        {
            res+= tmp[it]  ; 
        }
        return res ; 
    }
};

逆波兰表达式
注意switch语句很难用， 面试时最好少使用代码又长又容易出错。 switch 和 case是一条语句， 不能在中间定义变量
题意，把逆波兰表达式的值计算出来
思路： 遇到数字就要加入栈，遇到运算符，先弹出两个操作数，先弹出的操作数作为右操作数， 计算后把值放入栈。 直到遍历完毕
注意： 对于负数由于前面有负号与减号一样，所以需要特判 ；
核心代码：

  for(auto it : tokens)
        {
            //负数要特判， debug的时候，要对不通过的实例，进行演绎。
            if((it[0] >= '0' && it[0]<= '9')  || (it[0] == '-' && it.size()>=2) )
            {
                int t = stoi(it) ;
                cout<<t ; 
                st.push(t) ; 
            }
            else
            {
        int r ,l, t ; 
                switch(it[0])// switch和case是一条语句
                {
                    case '+':
                     r= st.top()  ;
                    st.pop() ;
                     l = st.top()  ;
                    st.pop() ;
                    cout<<r << " "<< l ; 
                     t = l+r ;
                    st.push(t) ;
                    break ; 
                    
                    case '-':
                     r = st.top()  ;
                    st.pop() ;
                     l = st.top()   ;
                    st.pop() ;
                     t = l-r ;
                    st.push(t) ;
                    break ;  

                    case '*' :
                     r = st.top()  ;
                     cout<<"*" <<r ; 
                    st.pop() ;
                     l = st.top() ;
                     cout<<"*" <<l  ; 

                    st.pop() ;
                     t = l*r ;
                    st.push(t) ;
                    break ;    

                    case '/':
                     r = st.top()  ;
                    st.pop() ;
                     l = st.top()  ;
                    st.pop() ;
                     t = l/r ;
                    st.push(t) ;
                    break ;                                      
                }

            }

        }

完全代码：

class Solution {
public:
    int evalRPN(vector<string>& tokens) 
    {
        stack<int> st ; 
        for(auto it : tokens)
        {
            //负数要特判， debug的时候，要对不通过的实例，进行演绎。
            if((it[0] >= '0' && it[0]<= '9')  || (it[0] == '-' && it.size()>=2) )
            {
                int t = stoi(it) ;
                cout<<t ; 
                st.push(t) ; 
            }
            else
            {
        int r ,l, t ; 
                switch(it[0])// switch和case是一条语句
                {
                    case '+':
                     r= st.top()  ;
                    st.pop() ;
                     l = st.top()  ;
                    st.pop() ;
                    cout<<r << " "<< l ; 
                     t = l+r ;
                    st.push(t) ;
                    break ; 
                    
                    case '-':
                     r = st.top()  ;
                    st.pop() ;
                     l = st.top()   ;
                    st.pop() ;
                     t = l-r ;
                    st.push(t) ;
                    break ;  

                    case '*' :
                     r = st.top()  ;
                     cout<<"*" <<r ; 
                    st.pop() ;
                     l = st.top() ;
                     cout<<"*" <<l  ; 

                    st.pop() ;
                     t = l*r ;
                    st.push(t) ;
                    break ;    

                    case '/':
                     r = st.top()  ;
                    st.pop() ;
                     l = st.top()  ;
                    st.pop() ;
                     t = l/r ;
                    st.push(t) ;
                    break ;                                      
                }

            }

        }
        int res =st.top();
        // st.pop() ; 
        return res ; 
    }
};