一、层序遍历

参考链接7.2 二叉树遍历 - Hello 算法 (hello-algo.com)

层序遍历本质上属于广度优先遍历，也称广度优先搜索，

BFS通常借助队列的先入先出的特性实现

参考链接102. 二叉树的层序遍历 - 力扣（LeetCode）

像这种较为固定思路的算法(层序遍历)，理解之后建议背诵复现

怎么样能按照“层”来打印二叉树？

1. 按层打印，从上至下，是二叉树的广度优先搜索(BFS)，使用队列实现
2. 将每一层打印在一行，并将下一行全部加入到队列中；循环直至queue为空

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

对照着理解

二、翻转二叉树

递归翻转

递归三要素参考链接2.2 迭代与递归 - Hello 算法 (hello-algo.com)

1. 终止条件：用于决定什么时候由“递”转“归”。
2. 递归调用：对应“递”，函数调用自身，通常输入更小或更简化的参数。
3. 返回结果：对应“归”，将当前递归层级的结果返回至上一层。

class Solution {
    public TreeNode invertTree(TreeNode root) {
        //终止条件
        if (root == null) return null;
        TreeNode tmp = root.left;
        //递归条件1
        root.left = invertTree(root.right);
        //递归条件2
        root.right = invertTree(tmp);
        //返回结果
        return root;
    }
}

三、对称二叉树

这题乍一看挺唬人，节点数量越多越难处理

参考链接101. 对称二叉树 - 力扣（LeetCode）

理解 树无论多少节点 最小逻辑处理单元 都是下图 理解该题就没有问题

class Solution {
    public boolean isSymmetric(TreeNode root) {
        return root == null || recur(root.left, root.right);
    }
    boolean recur(TreeNode L, TreeNode R) {
        if (L == null && R == null) return true;
        if (L == null || R == null || L.val != R.val) return false;
        return recur(L.left, R.right) && recur(L.right, R.left);
    }
}

四、其实反反复复考的还是DFS前中后序，BFS层序遍历的理解