[Leedcode][JAVA][第94/144/145题][前中后序遍历][递归][迭代][二叉树]

【问题描述】[]

• 前序遍历 先输出当前结点的数据，再依次遍历输出左结点和右结点

• 中序遍历 先遍历输出左结点，再输出当前结点的数据，再遍历输出右结点
  
• 后续遍历 先遍历输出左结点，再遍历输出右结点，最后输出当前结点的数据

【解答思路】

递归 /迭代（栈）
时间复杂度：O(N) 空间复杂度：O(N)

1. 前序遍历

1.1 递归
二叉树遍历（前序、中序、后序）的递归方法，唯一改变的是记录节点值操作的位置

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

1.2 迭代（栈）
需要一个辅助栈

class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()) {
            while (cur != null) {
            //立马加入当前值
                list.add(cur.val);
                stack.push(cur);
                cur = cur.left; //考虑左子树
            }
                //节点为空，就出栈
                cur = stack.pop();
                //考虑右子树
                cur = cur.right;
            
        }
        return list;
}

}

2. 中序遍历

1.1 递归
二叉树遍历（前序、中序、后序）的递归方法，唯一改变的是记录节点值操作的位置

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

1.2 迭代（栈）
需要一个辅助栈

public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> ans = new ArrayList<>();
    Stack<TreeNode> stack = new Stack<>();
    TreeNode cur = root;
    while (cur != null || !stack.isEmpty()) {
        //节点不为空一直压栈
        while (cur != null) {
            stack.push(cur);
            cur = cur.left; //考虑左子树
        }
        //节点为空，就出栈
        cur = stack.pop();
        //当前值加入
        ans.add(cur.val);
        //考虑右子树
        cur = cur.right;
    }
    return ans;
}

作者：windliang
链接：https://leetcode-cn.com/problems/binary-tree-postorder-traversal/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by--34/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

3. 后序遍历

1.1 递归
二叉树遍历（前序、中序、后序）的递归方法，唯一改变的是记录节点值操作的位置

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

1.2 迭代（栈）
需要两个辅助栈
-从根节点开始依次迭代，弹出栈顶元素输出到输出列表中，然后依次压入它的所有孩子节点，按照从上到下、从左至右的顺序依次压入栈中。

-因为深度优先搜索后序遍历的顺序是从下到上、从左至右，所以需要将输出列表逆序输出。

class Solution {
    List<Integer> res = new ArrayList<>();
    public List<Integer> postorderTraversal(TreeNode root) {
        if (root == null) {
            return res;
        }
        LinkedList<TreeNode> stack = new LinkedList<>();
        LinkedList<TreeNode> stackTemp = new LinkedList<>();
        stackTemp.push(root);
        while (!stackTemp.isEmpty()) {
            TreeNode curNode = stackTemp.pop();
            //stack压入
            stack.push(curNode);
            if (curNode.left != null) {
                stackTemp.push(curNode.left);
            }
            if (curNode.right != null) {
                stackTemp.push(curNode.right);
            }
        }
        //逆序
        while (!stack.isEmpty()) {
            res.add(stack.pop().val);
        }
        return res;
    }
}

1.3 转换思想 后续转前序 逆转

后序遍历的顺序是 左 -> 右 -> 根。
前序遍历的顺序是 根 -> 左 -> 右，
左右其实是等价的，所以我们也可以轻松的写出 根 -> 右 -> 左 的代码。
然后把 根 -> 右 -> 左 逆序，就是 左 -> 右 -> 根，也就是后序遍历了。

public List<Integer> postorderTraversal2(TreeNode root) {
    List<Integer> list = new ArrayList<>();
    Stack<TreeNode> stack = new Stack<>();
    TreeNode cur = root;
    while (cur != null || !stack.isEmpty()) {
        if (cur != null) {
            list.add(cur.val);
            stack.push(cur);
            cur = cur.right; // 考虑右子树
        } else {
            // 节点为空，就出栈
            cur = stack.pop();
            // 考虑左子树
            cur = cur.left;
        }
    }
    //翻转
    Collections.reverse(list);
    return list;
}

1.4 一个栈

public List<Integer> postorderTraversal(TreeNode root) {
        if (root == null) return new ArrayList<Integer>();
        
        TreeNode node = root;
        List<Integer> ret = new ArrayList<Integer>();
        
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while(node != null || !stack.isEmpty()) {
            while (node != null) {
                stack.push(node);
                node = node.left;
            }
            node = stack.pop();
            // 后序遍历
            // 如果没有右孩子或者右孩子被访问过了 {@Alex Zheng 感谢建议哈～}
            if (node.right == null || 
                    (ret.size() != 0 && ret.get(ret.size() - 1).equals(node.right.val)) ) {
                ret.add(node.val);
                node = null;
            }  else {
                stack.push(node);
                node = node.right;
            }
        }
        return ret;
    }


链接：https://leetcode-cn.com/problems/binary-tree-postorder-traversal/solution/bian-li-tong-jie-by-long_wotu/

【总结】

1. 前中后序遍历变化的是[中]的位置，左到右的顺序不改变

• 前序遍历 中左右
• 中序遍历 左中右
• 后续遍历 左右中

2.pop 与 poll 都是取出 LinkedList 的第一个元素，并将该元素删除，等效于：removeFirst

不同点：两者的实现所用数据结构不同，

• poll 是基于队列结构实现的方法，当队列中没有元素时，调用该方法返回 null
• pop 是基于栈结构实现的方法，当栈中没有元素时，调用该方法会发生异常

3. 递归模板

res.add(root.val); 位置动态变化

public List<Integer> preorderTraversal(TreeNode root) {
        if (root != null) {
           //先序遍历 res.add(root.val);
            preorderTraversal(root.left);
              //中序遍历 res.add(root.val);
            preorderTraversal(root.right);
              //后序遍历 res.add(root.val);
        }
        return res;
    }

4. 迭代模板

list.add(cur.val);位置动态变化
前中序可遍历，后续遍历可由前序遍历修改后逆转

public List<Integer> preorderTraversal(TreeNode root) {
       List<Integer> list = new ArrayList<>();
       Stack<TreeNode> stack = new Stack<>();
       TreeNode cur = root;
       while (cur != null || !stack.isEmpty()) {
           while (cur != null) {

               stack.push(cur);
               // 先序遍历   list.add(cur.val);
               cur = cur.left; 
           }
               //节点为空，就出栈
               cur = stack.pop();
               // 中序序遍历   list.add(cur.val);
               cur = cur.right;
               //后序遍历   list.add(cur.val);  需要变得多
           
       }
       return list;
}

参考链接:https://leetcode.wang/leetcode-145-Binary-Tree-Postorder-Traversal.html