栈 - 20 Valid Parentheses, 150 Evaluate Reverse Polish Notation

注意：！！当字符串的某一字符为 ）}  ] 时要先判断栈st是否为空，若为空则返回false，否则st.pop()时容易造成指针溢出报错。

class Solution {
public:
    bool isValid(string s) {
        if(s.empty())
            return true;
        stack<char> st;
        for(auto a : s){
            if(a=='(' || a=='['|| a=='{')
                st.push(a);
            else
            {
                if(st.empty())  //注意判断栈是否为空，否则st.pop()会导致内存泄漏
                    return false;
                else if(a==')')
                {
                if(st.top()== '(')
                    st.pop();
                else
                    return false;
                }
                else if(a=='}'){
                if(st.top() == '{')
                    st.pop();
                else
                    return false;
                }
                else{
                if(st.top()== '[')
                    st.pop();
                else
                    return false;
                }
            }
        }

        if(st.empty())
            return true;
        else
            return false;
    }
};

class Solution {
public:
    bool isValid(string s) {
        stack<char> st;
        for(int i=; i<s.size(); i++){
            if(s[i] == '(' || s[i] == '{'|| s[i] == '[')
                st.push(s[i]);
            else{
                //不要忘记判断边界条件
                if(st.size() == )
                    return false;

                char c = st.top();
                st.pop();

                char match;
                if(s[i]==')')
                    match = '(';
                else if(s[i]=='}')
                    match = '{';
                else
                {
                    assert(s[i]==']');
                    match = '[';

                }
                if(c != match)
                    return false;
            }
        }
        if(st.size() != )
            return false;
        return true;
    }

};

思路：从前往后遍历数组，遇到数字则压入栈中，遇到符号则把栈顶的两个数字拿出来做运算，把结果再压入栈中，直到遍历完整个数组，栈顶数字就是答案。

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

                if(tokens[i] == "+")
                    st.push(num1 + num2);
                else if(tokens[i] == "-")
                    st.push(num2 - num1);
                else if(tokens[i] == "*")
                    st.push(num2 * num1);
                else{
                    assert(tokens[i] == "/");
                    st.push(num2 / num1);
                }

            }

        }
        return st.top();
    }
};

.. 回退一个目录

思路：使用stringstream来分割字符串，使用字符串t来保存每一段，然后分布处理：当中间是“.”就要直接去掉；多个“/”只保留一个；“..”是回退上一级的意思，即若栈不为空，弹出栈顶元素；最后，将符合要求的字符串压入栈。

class Solution {
public:
    string simplifyPath(string path) {
        string res, t;
        stringstream ss(path);
        vector<string> v;

        while(getline(ss,t,'/')){  //以 / 来分割ss，获得的字符串赋给t
            if(t == "" || t == ".") continue;  //跳出本次循环，执行下一个循环
            else if(t != ".." )
                v.push_back(t);
            else if(!v.empty())
                v.pop_back();
        }

        for(string s:v)
            res += "/" + s;
        return res.empty() ? "/" : res;
    }
};