算法学习：栈

- 简化路径

给你一个字符串 path ，表示指向某一文件或目录的 Unix 风格 绝对路径 （以 ‘/’ 开头），请你将其转化为更加简洁的规范路径。
在 Unix 风格的文件系统中，一个点（.）表示当前目录本身；此外，两个点 （…） 表示将目录切换到上一级（指向父目录）；两者都可以是复杂相对路径的组成部分。任意多个连续的斜杠（即，’//’）都被视为单个斜杠 ‘/’ 。 对于此问题，任何其他格式的点（例如，’…’）均被视为文件/目录名称。
请注意，返回的 规范路径 必须遵循下述格式：
始终以斜杠 ‘/’ 开头。
两个目录名之间必须只有一个斜杠 ‘/’ 。
最后一个目录名（如果存在）不能 以 ‘/’ 结尾。
此外，路径仅包含从根目录到目标文件或目录的路径上的目录（即，不含 ‘.’ 或 ‘…’）。
返回简化后得到的 规范路径 。

class Solution {
public:
    string simplifyPath(string path) {
        vector<string>v;
        int n = path.size();
        int idx = 0;
        int len = 0;
        for(int i = 0; i < n; i++){
            if(path[i] == '/'){
                if(len != 0){
                    v.push_back(path.substr(idx, len));
                }
                len = 0;
                idx = i + 1;
            }else{
                len++;
                if(i == n - 1){
                    v.push_back(path.substr(idx, len));
                }
            }   
        }
        
        int vn = v.size();
        int i = 0;
        while(i < vn){
            if(v[i] == "."){
                v.erase(v.begin() + i);
                i--;
                vn--;
            }
            else if(v[i] == ".."){
                if(i == 0){
                    v.erase(v.begin());
                    i--;
                    vn--;
                }
                else{
                    v.erase(v.begin() + i - 1, v.begin() + i + 1);
                    i -= 2;
                    vn -= 2;
                }
            }
            i++;
        }
        string reslut = "/";
        vn = v.size();
        for(int i = 0; i < vn; i++){
            reslut +=  v[i];
            if(i != vn - 1)
                reslut += "/";
        }
        return reslut;
    }
};

经验：
1、不知道C++的正则能不能用，如果是python直接一个split就甩过去了，会快很多。
2、比较简单的栈题，只是如果考试不给测试用例的话还是比较恶心的，譬如题目当中在根目录下执行"/…”是TM的合法的。
3、c++中的vector可以利用push_back王丽添加元素，也可以利用pop_back弹出最后一个元素，还可以利用erase来删除中间的元素。

- 二叉树的锯齿形层序遍历

给定一个二叉树，返回其节点值的锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {

        int reverse = 1;
        queue<TreeNode*> q;
        vector<vector<int>>result;
        if(!root)
            return result;
        q.push(root);
        int depth = 0;
        while(!q.empty()){
            deque<int>row;
            if(reverse){
                int n = q.size();
                for(int i = 0; i < n; i++){
                    TreeNode* temp = q.front();
                    q.pop();
                    row.push_back(temp->val);
                    if(temp->left)
                        q.push(temp->left);
                    if(temp->right)
                        q.push(temp->right);
                }
            }
            else{
                int n = q.size();
                for(int i = 0; i < n; i++){
                    TreeNode* temp = q.front();
                    q.pop();
                    row.push_front(temp->val);
                    if(temp->left)
                        q.push(temp->left);
                    if(temp->right)
                        q.push(temp->right);
                }
            }
            reverse ^= 1;
            result.emplace_back(vector<int>{row.begin(), row.end()});
        }
        return result;
    }
};

经验：
1、第一次用到了C++除了vector以外的东西hh，不过这题主要是队列，和栈没啥关系
2、queue的方法：front队列首元素，pop弹出首元素，push插入队列
3、deque是一个双向的vector，支持push_front
4、vector中有emplace_back(vector<>{iter.begin(), iter.end()})
5、注意题目当中的形参是指针还是引用
6、题目不难，主要是用了新的数据结构

*** 逆波兰表达式求值**

根据 逆波兰表示法，求表达式的值。
有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

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

经验：
1、注意栈的出栈顺序
2、stoi可以将字符串转换成整数，只要其不超过int的范围。atoi需要调用string的c_str方法，该函数的参数为char*[]
3、注意栈出来的顺序，后出来的数字应当是被除数。