天猫高频编程考题：翻转二叉树（简单）

题目描述

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

示例 2：

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

示例 3：输入：root = [] 输出：[]

提示：

• 树中节点数目范围在 [0, 100] 内
• -100 <= Node.val <= 100

解题思路

定义：翻转二叉树的操作是交换每个节点的左子树和右子树。这个操作从根节点开始，然后递归地进行到每个子节点。递归：

1. 基本情况：如果当前节点为空（root == null），则返回 null。
2. 交换子树：交换当前节点的左子树和右子树。
3. 递归调用：递归地对左子树和右子树进行翻转。
4. 返回节点：返回当前节点（其子树已经翻转）。

复杂度分析

• 时间复杂度：O(n)。其中 n 是树中的节点数。每个节点都需要访问一次以进行交换和递归操作。因此，时间复杂度是 O(n)。

• 空间复杂度：O(h)。其中 h 是树的高度。递归调用会消耗栈空间，栈的深度是树的高度。最坏情况下，树是链式结构（即退化为单边树），高度为 n，所以空间复杂度是 O(n)。但对于平衡树，树的高度是 log(n)，因此在平衡树的情况下，空间复杂度是 O(log n)。

代码实现

package org.zyf.javabasic.letcode.hot100.tree;

import org.zyf.javabasic.letcode.tree.base.TreeNode;

/**
 * @program: zyfboot-javabasic
 * @description: 翻转二叉树（简单）
 * @author: zhangyanfeng
 * @create: 2024-08-22 11:00
 **/
public class InvertTreeSolution {
    // 翻转二叉树的递归方法
    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 void printInOrder(TreeNode root) {
        if (root != null) {
            printInOrder(root.left);
            System.out.print(root.val + " ");
            printInOrder(root.right);
        }
    }

    // 测试主函数
    public static void main(String[] args) {
        // 构造测试用例
        TreeNode root1 = new TreeNode(4);
        root1.left = new TreeNode(2);
        root1.right = new TreeNode(7);
        root1.left.left = new TreeNode(1);
        root1.left.right = new TreeNode(3);
        root1.right.left = new TreeNode(6);
        root1.right.right = new TreeNode(9);

        TreeNode root2 = new TreeNode(2);
        root2.left = new TreeNode(1);
        root2.right = new TreeNode(3);

        TreeNode root3 = null;

        // 创建 Solution 实例并进行测试
        InvertTreeSolution solution = new InvertTreeSolution();

        // 翻转并打印结果
        TreeNode invertedRoot1 = solution.invertTree(root1);
        TreeNode invertedRoot2 = solution.invertTree(root2);
        TreeNode invertedRoot3 = solution.invertTree(root3);

        System.out.print("Inverted Tree 1 (InOrder): ");
        solution.printInOrder(invertedRoot1); // 输出应为 9 7 6 4 3 2 1
        System.out.println();

        System.out.print("Inverted Tree 2 (InOrder): ");
        solution.printInOrder(invertedRoot2); // 输出应为 3 2 1
        System.out.println();

        System.out.print("Inverted Tree 3 (InOrder): ");
        solution.printInOrder(invertedRoot3); // 输出应为空
        System.out.println();
    }
}

  具体可见：LeetCode 热题 100 回顾_leetcode热题100-CSDN博客