代码随想录-二叉树 | 迭代遍历

LeetCode 144-前序遍历、94-中序遍历、145-后序遍历

题目链接-前序遍历
题目链接-中序遍历
题目链接-后序遍历
代码随想录

题目描述

给你二叉树的根节点 root ，分别返回它节点值的 前序、中序、后序 遍历。

解题思路

判断：

• 这里直接采用迭代遍历解法。
• 递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。

因此我们用栈也可以实现二叉树的前后中序遍历。代码中，空节点不入栈。

• 前序遍历：根-左-右。因此，先将根节点放入栈中，再放右孩子，最后放左孩子（这样出栈时的顺序为 根-左-右）。
• 中序遍历：左-根-右。（处理顺序和访问顺序不一致，不能直接应用上面的逻辑）借用指针的遍历来帮助访问节点，栈用于处理节点上的元素。
• 后序遍历：左-右-根。调整前序遍历的左右顺序（根-右-左），再反转result数组，输出的结果即为（左-右-根）。

代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */

前序遍历：

 //前序遍历顺序：根-左-右，入栈顺序：根-右-左
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        if(root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if(node.right != null){
                stack.push(node.right);
            }
            if(node.left != null){
                stack.push(node.left);
            }
        }
        return result;
    }
}

中序遍历：

//中序遍历顺序：左-根-右，入栈顺序：左-右
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        if(root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()){
            if(cur != null){
                stack.push(cur);
                cur = cur.left;
            }else{
                cur = stack.pop();
                result.add(cur.val);
                cur = cur.right;
            }
        }
        return result;
    }
}

后序遍历：

//后序遍历顺序：左-右-根，入栈顺序：根-左-右，出栈顺序：根-右-左，最后反转result
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if(root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if(node.left != null){
                stack.push(node.left);
            }
            if(node.right != null){
                stack.push(node.right);
            }
        }
        Collections.reverse(result);
        return result;
    }
}

难点

• 中序遍历与前序遍历的代码风格不同，不能只是稍作调整。这是由于前序遍历时访问节点和处理节点可以同步处理（即，访问和处理的都是中间节点），而中序遍历时无法同步。

在迭代的过程中，我们两个操作：

1. 访问：遍历节点
2. 处理：将元素放进result数组中

总结

学习到新知识：用迭代法写二叉树的前中后序遍历。注意到前序和中序的代码风格是完全不一样的。