栈

栈的基本使用

例题：有效的括号

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符串。

很经典的题目，当初第一次做还是个懵懂的少年，现在头发刷刷的掉。
利用栈可以很轻松的实现，遇到左括号就进栈，右括号就出栈栈顶元素进行匹配。如果匹配错误或者栈为空，则返回false。
当然，如果最后运行结束栈为空，返回true；否则返回false。

class Solution {
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<Character>();
        for(int i=0;i<s.length();i++){
            char cur = s.charAt(i);
            if(cur=='(' || cur=='[' || cur=='{'){
                stack.push(cur);
            }else{
                if(stack.empty()) return false;
                switch(stack.pop()){
                    case '(':
                        if(cur!=')') return false;
                        break;
                    case '{':
                        if(cur!='}') return false;
                        break;
                    case '[':
                        if(cur!=']') return false;
                        break;
                }
            }
        }
        return stack.empty()?true:false;
    }
}

1.逆波兰表达式求值

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

说明： 整数除法只保留整数部分。 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

逆波兰表达式也就是学的“后缀表达式”，具体算法如下所示：

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

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<String> stack = new Stack<String>();
        for(String s:tokens){
            if(s.equals("+")){
                int a = Integer.parseInt(stack.pop());
                int b = Integer.parseInt(stack.pop());
                stack.push(String.valueOf(a+b));
            }else if(s.equals("-")){
                int a = Integer.parseInt(stack.pop());
                int b = Integer.parseInt(stack.pop());
                stack.push(String.valueOf(b-a));
            }else if(s.equals("*")){
                int a = Integer.parseInt(stack.pop());
                int b = Integer.parseInt(stack.pop());
                stack.push(String.valueOf(a*b));
            }else if(s.equals("/")){
                int a = Integer.parseInt(stack.pop());
                int b = Integer.parseInt(stack.pop());
                stack.push(String.valueOf(b/a));
            }else{
                stack.push(s);
            }
        }
        return Integer.parseInt(stack.pop());
    }
}

2.简化路径

以 Unix 风格给出一个文件的绝对路径，你需要简化它。或者换句话说，将其转换为规范路径。

在 Unix 风格的文件系统中，一个点（.）表示当前目录本身；此外，两个点 （…）表示将目录切换到上一级（指向父目录）；两者都可以是复杂相对路径的组成部分。

请注意，返回的规范路径必须始终以斜杠 / 开头，并且两个目录名之间必须只有一个斜杠 /。最后一个目录名（如果存在）不能以 /结尾。此外，规范路径必须是表示绝对路径的最短字符串。

这个题，乍一看复杂之极，但实际上懂一些文件路径便能轻松解决：

• 第一步，按照/来分割字符串；
• 对每一个分割后的字符串判断：
  • 如果是单词，那么就先入栈一个/，再将单词入栈；
  • 如果是.或者，就按兵不动；
  • 如果是..，就出栈两个元素，如果栈为空，就不动；
• 遍历完数组后，此时栈中的元素，全部出栈，逆向拼接即可。

class Solution {
    public String simplifyPath(String path) {
        String[] array = path.split("/");
        Stack<String> stack = new Stack<String>();
        for(String s:array){
            if(s.equals("..")){
                if(!stack.empty()){
                    stack.pop();
                    stack.pop();
                }
            }else if(s.equals(".") || s.equals("")){
            }else{
                stack.push("/");
                stack.push(s);
            }
        }
        StringBuilder sb = new StringBuilder();
        while(!stack.empty()){
            sb.insert(0,stack.pop());
        }
        return sb.length()==0?"/":sb.toString();
    }
}

栈和递归的紧密关系

1.二叉树的前序遍历

前序的顺序为[根，左，右]，所以使用递归，深度优先遍历代码如下：

class Solution {
    List<Integer> list = new ArrayList<Integer>();
    public List<Integer> preorderTraversal(TreeNode root) {
        if(root!=null) preorder(root);
        return list;
    }
    public void preorder(TreeNode root){
        list.add(root.val);
        if(root.left!=null) preorder(root.left);
        if(root.right!=null) preorder(root.right);
    }
}

可以不使用递归，而使用一个栈来实现：

• 先将root进栈（不为null）
• 如果栈不为空，就循环：每次对于取出的node，先将自身的值添加到列表中，再将右孩子进栈，最后将左孩子进栈。

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        if(root!=null) stack.push(root);
        while(!stack.empty()){
            TreeNode t = stack.pop();
            list.add(t.val);
            if(t.right!=null) stack.push(t.right);
            if(t.left!=null) stack.push(t.left);
        }
        return list;
    }
}

2.二叉树的中序遍历

原理都一样，只是代码顺序不同：

class Solution {
    List<Integer> list = new ArrayList<Integer>();
    public List<Integer> inorderTraversal(TreeNode root) {
        if(root!=null) inorder(root);
        return list;
    }
    public void inorder(TreeNode root){
        if(root.left!=null) inorder(root.left);
        list.add(root.val);
        if(root.right!=null) inorder(root.right);
    }
}

感觉中序遍历的迭代方法不是很好理解

• 因为先输出左子树，所以先将当前结点p进栈，然后一路将所有左子树都进栈；
• 出栈一个结点，此时该结点的左子树已经被访问过了，所以输出该结点值；
• 然后p指向右结点，开始下一轮循环。

栈S;
p= root;
while(p || S不空){
    while(p){
        p入S;
        p = p的左子树;
    }
    p = S.top 出栈;
    访问p;
    p = p的右子树;
}

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode p = root;
        while(p!=null || !stack.empty()){
            while(p!=null){
                stack.push(p);
                p = p.left;
            }
            p = stack.pop();
            list.add(p.val);
            p = p.right;
        }
        return list;
    }
}

3.二叉树的后序遍历

class Solution {
    List<Integer> list = new ArrayList<Integer>();
    public List<Integer> postorderTraversal(TreeNode root) {
        if(root!=null) postorder(root);
        return list;
    }
    public void postorder(TreeNode root){
        if(root.left!=null) postorder(root.left);
        if(root.right!=null) postorder(root.right);
        list.add(root.val);
    }
}

明白了中序迭代的思路，后序其实差不多。不过需要注意，要区分开从左结点回来的，和从右结点回来的，所以要打上一个标记。
当两个子树都访问过了，将该结点的标志位置为true。

栈S;
p= root;
T<节点,True/False> : 节点标记;
while(p || S不空){
    while(p){
        p入S;
        p = p的左子树;
    }
    while(S不空 且 T[S.top] = True){
        访问S.top;
        S.top出S;
    }
    if(S不空){
        p = S.top 的右子树;
        T[S.top] = True;
    }
}

4.