算法训练营day12 二叉树（递归遍历，迭代遍历，统一迭代，层序遍历）

💡 解题思路

1. 📝 确定输入与输出
2. 🔍 分析复杂度
3. 🔨 复杂题目拆分 ：严谨且完整 地拆分为更小的可以解决的子问题（二叉树的不同遍历方式）–（多总结）
4. 💭 选择处理逻辑： 根据拆分后的子问题，总结并选择合适的问题处理思路（前，中，后序，层序遍历）
5. 🔎 检查特殊情况：边界条件和特殊情况（递归返回值、递归顺序）
6. 🏁 返回结果

---

递归遍历
144.二叉树的前序遍历
94.二叉树的中序遍历
145.二叉树的后序遍历

class Solution {
    List<Integer> res ;
    public List<Integer> preorderTraversal(TreeNode root) {
        res = new ArrayList<>();
        reverse(root);
        return res;
    }
    public void reverse(TreeNode node) {
        if (node == null) return;
        // 前序遍历
        reverse(node.left);
        // 中序遍历
        reverse(node.right);
        // 后序遍历
    }
}

迭代遍历
1、前序遍历：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
       List<Integer> res = new ArrayList<>();
       if (root == null) return res;
       Stack<TreeNode> stack = new Stack<>();
       stack.push(root);
       while(!stack.isEmpty()) {
            TreeNode node = stack.pop();
            res.add(node.val);
            // 栈的属性：(先入后出，后入先出)
            if (node.right != null) stack.push(node.right); 
            if (node.left != null) stack.push(node.left);
       }
       return res; 
    }
}

2、中序遍历：(访问顺序和处理顺序不一致)（处理顺序 和 右节点无关）

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

3、后序遍历：（处理顺序和右节点有关）
方法一：（逻辑遍历）

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) return res;
        Stack<TreeNode> stack = new Stack<>();
        TreeNode pre = null; // 标记右节点，是否被遍历过
        while(root != null || !stack.isEmpty()) {
            if (root != null) {
                stack.push(root);
                root = root.left;
            } else {
                root = stack.pop();
                if (root.right != null && root.right != pre) {
                    stack.push(root);
                    root = root.right;
                } else {
                    res.add(root.val);   
                    pre = root;
                    root = null;
                }
            }
        }
        return res;
    }
}

方法二：
两步：中右左（前序）-> 反转（左右中）

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) return res;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()) {
            TreeNode node = stack.pop();
            res.add(node.val);
            if (node.left != null) stack.push(node.left);
            if (node.right != null) stack.push(node.right);
        }
        Collections.reverse(res);
        return res;
    }
}

统一迭代
1、前序遍历：（注意栈的 出栈、入栈顺序）

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

2、中序遍历：

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

3、后序遍历：

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

层序遍历
迭代法：

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> resList = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                root = queue.poll();
                resList.add(root.val);
                if (root.left != null) queue.offer(root.left);
                if (root.right != null) queue.offer(root.right);
            }
            res.add(resList);
        }
        return res;
    }
}

递归法：

class Solution {
    List<List<Integer>> res;
    public List<List<Integer>> levelOrder(TreeNode root) {
        res = new ArrayList<>();
        reverse(root, 1);
        return res;
    }
    private void reverse(TreeNode node, int depth) {
        if (node == null) return;
        if (res.size() < depth) {
            List<Integer> resList = new ArrayList<>();
            res.add(resList);
        }
        res.get(depth-1).add(node.val);
        reverse(node.left, depth+1);
        reverse(node.right, depth+1);
    }
}