二叉树之遍历

2021.11.28

所有递归问题都可以抽象为二叉树的遍历。

1、二叉树的前序遍历

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

示例 1：

输入：root = [1,null,2,3]
输出：[1,2,3]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

思路

递归

临界条件：root = null

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

迭代

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> stack = new LinkedList<>();
        TreeNode node = root;
        if (root == null) {
            return res;
        }
        //当栈不为空，或节点不为null
        while (!stack.isEmpty() || node != null) {
            while (node != null) {
                //一个节点一个节点的压栈，每压一个，就存入，导致根节点都是最先存入的。
                res.add(node.val);
                stack.push(node);
                node = node.left;
            }
            //当node为null时，到达最左叶子节点，这时出栈，依次向上寻找右子节点。
            node = stack.pop();
            node = node.right;
        }
        return res;
    }
}

2、二叉树的中序遍历

递归

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

迭代

中序遍历，只需要修改获取res的位置即可，全部压栈之后，一个一个出栈的时候再一个一个加入到res，这样就能保证根节点在左右节点中间被读取了。

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> stack = new LinkedList<>();
        TreeNode node = root;
        while (!stack.isEmpty() || node != null) {
            while (node != null) {
                stack.push(node);
                node = node.left;
            }
            node = stack.pop();
            res.add(node.val);
            node = node.right;
        }
        return res;
    }
}

3、二叉树的后序遍历

递归

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

迭代（反复咀嚼）

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Deque<TreeNode> stack = new LinkedList<>();//辅助栈
        TreeNode prev = null;//用来记录根节点的右子节点是否已经记录
        while (!stack.isEmpty() || root != null) {
            //与中序遍历相同，一直找到最左叶子节点
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            //一个一个出栈
            root = stack.pop();
            //若右子节点为空，或者右子节点已被记录
            //为空的时候，记录
            //右子节点已被记录，这下轮到最后的根节点进行记录。记录完毕，将根节点指向null
            if (root.right == null || root.right == prev) {
                res.add(root.val);
                prev = root;
                root = null;
            } else {
                //右子节点未被记录，迭代记录右子节点，将根节点入队。
                stack.push(root);
                root = root.right;
            }
        }
        return res;
    }
}

4、二叉树的层序遍历

思路

维护一个队列，开始将根节点入队，然后记录队列大小这个大小就是每层的节点数，for循环根据每层的节点数，记录这一层的节点，并且将这一层的每个节点的子节点全部入队，当循环结束，一层就遍历完毕了。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            List<Integer> floorRes = new ArrayList<>();
            for (int i = 0; i < size ; i++) {
                root = queue.poll();
                floorRes.add(root.val);
                if (root.left != null) {
                    queue.offer(root.left);
                }
                if (root.right != null) {
                    queue.offer(root.right);
                }
            }
            res.add(floorRes);
        }
        return res;
    }
}

``