代码随想录第十五天

226.翻转二叉树 （优先掌握递归）

这道题目 一些做过的同学 理解的也不够深入，建议大家先看我的视频讲解，无论做过没做过，都会有很大收获。

题目链接/文章讲解/视频讲解：https://programmercarl.com/0226.%E7%BF%BB%E8%BD%AC%E4%BA%8C%E5%8F%89%E6%A0%91.html

思路：

步骤：

1. 定义二叉树节点类TreeNode，包括值val、左子树left和右子树right。
2. 创建BinaryTreeFlip类，其中包含一个invertTree方法用于翻转二叉树。该方法采用递归的方式实现翻转操作，并返回翻转后的根节点。
3. 在invertTree方法中，先判断当前节点是否为空，若为空则直接返回。
4. 交换当前节点的左右子树，使用临时变量temp进行交换。
5. 递归调用invertTree方法翻转当前节点的左右子树。
6. 最后返回根节点。
7. 在main方法中，构建一棵二叉树，并调用invertTree方法翻转二叉树。
8. 使用层序遍历的方式输出翻转后的二叉树，定义printTree方法实现该功能。
9. 运行程序，得到翻转后的二叉树的层序遍历结果。

完整代码

// 定义二叉树节点类
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode(int val) {
        this.val = val;
    }
}

public class BinaryTreeFlip {
    public TreeNode invertTree(TreeNode root) {
        // 递归结束条件，当节点为空时直接返回
        if (root == null) {
            return null;
        }

        // 交换当前节点的左右子树
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;

        // 递归翻转左右子树
        invertTree(root.left);
        invertTree(root.right);

        return root;
    }

    public static void main(String[] args) {
        // 构建二叉树
        TreeNode root = new TreeNode(4);
        root.left = new TreeNode(2);
        root.right = new TreeNode(7);
        root.left.left = new TreeNode(1);
        root.left.right = new TreeNode(3);
        root.right.left = new TreeNode(6);
        root.right.right = new TreeNode(9);

        BinaryTreeFlip flip = new BinaryTreeFlip();
        TreeNode flippedRoot = flip.invertTree(root);

        // 输出翻转后的二叉树
        printTree(flippedRoot);
    }

    // 层序遍历输出二叉树
    private static void printTree(TreeNode root) {
        if (root == null) {
            return;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            System.out.print(node.val + " ");

            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
    }
}

101. 对称二叉树 （优先掌握递归）

先看视频讲解，会更容易一些。

题目链接/文章讲解/视频讲解：https://programmercarl.com/0101.%E5%AF%B9%E7%A7%B0%E4%BA%8C%E5%8F%89%E6%A0%91.html

思路：

步骤：

1. 定义二叉树节点类TreeNode，包括值val、左子树left和右子树right。
2. 创建BinaryTreeSymmetric类，其中包含一个isSymmetric方法用于判断二叉树是否轴对称。该方法调用递归函数symmetric判断左右子树是否对称，并返回结果。
3. 在symmetric方法中，先判断左右子树是否都为空，若是则对称，返回true。
4. 若左右子树一个为空，一个不为空，则不对称，返回false。
5. 若左右子树的值不相等，则不对称，返回false。
6. 递归判断左子树的左节点和右子树的右节点、左子树的右节点和右子树的左节点是否对称，若都对称，则左右子树对称，返回true。
7. 在main方法中，分别构建对称和非对称的二叉树，并调用isSymmetric方法判断二叉树是否轴对称。
8. 输出结果。
9. 运行程序，得到对称和非对称二叉树的判断结果。

完整代码

// 定义二叉树节点类
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode(int val) {
        this.val = val;
    }
}

public class BinaryTreeSymmetric {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }

        // 调用递归函数判断左右子树是否对称
        return symmetric(root.left, root.right);
    }

    private boolean symmetric(TreeNode left, TreeNode right) {
        // 递归结束条件，左右子树都为空时对称
        if (left == null && right == null) {
            return true;
        }

        // 左右子树一个为空，一个不为空时不对称
        if (left == null || right == null) {
            return false;
        }

        // 左右子树值不相等时不对称
        if (left.val != right.val) {
            return false;
        }

        // 递归判断左子树的左节点和右子树的右节点、左子树的右节点和右子树的左节点是否对称
        return symmetric(left.left, right.right) && symmetric(left.right, right.left);
    }

    public static void main(String[] args) {
        // 构建对称的二叉树
        TreeNode root1 = new TreeNode(1);
        root1.left = new TreeNode(2);
        root1.right = new TreeNode(2);
        root1.left.left = new TreeNode(3);
        root1.left.right = new TreeNode(4);
        root1.right.left = new TreeNode(4);
        root1.right.right = new TreeNode(3);

        // 构建非对称的二叉树
        TreeNode root2 = new TreeNode(1);
        root2.left = new TreeNode(2);
        root2.right = new TreeNode(2);
        root2.left.right = new TreeNode(3);
        root2.right.right = new TreeNode(3);

        BinaryTreeSymmetric symmetric = new BinaryTreeSymmetric();
        System.out.println(symmetric.isSymmetric(root1)); // true
        System.out.println(symmetric.isSymmetric(root2)); // false
    }
}