leetcode 226. 翻转二叉树 java解法

题目描述

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

翻转一棵二叉树意味着交换每个节点的左右子树。我们可以使用递归的方法，从根节点开始，对每个节点进行如下操作：

交换当前节点的左右子树。
递归地翻转当前节点的左子树。
递归地翻转当前节点的右子树。

递归的终止条件是当前节点为 null，即叶子节点。
解法

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

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

public class Solution {
    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 printTree(TreeNode root) {
        if (root != null) {
            System.out.println(root.val);
            printTree(root.left);
            printTree(root.right);
        }
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        
        // 构造二叉树
        //       4
        //      / \
        //     2   7
        //    / \ / \
        //   1  3 6  9
        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);

        // 执行翻转操作
        TreeNode invertedRoot = solution.invertTree(root);

        // 输出结果
        System.out.println("翻转后的二叉树：");
        solution.printTree(invertedRoot);
    }
}

时间复杂度分析

递归函数需要访问每个节点恰好一次，因此时间复杂度为 O(n)，其中 n 是树中节点的数量。
空间复杂度分析

递归函数在递归过程中使用的栈空间的最大深度等于树的高度，最坏情况下，树是一个链表结构，高度为 n，因此空间复杂度为 O(n)。