【leetcode hot 100】 二叉树2

1.

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        // 空节点或叶子节点直接返回
        if (root == nullptr) {
            return nullptr;
        }
        
        // 交换左右子树
        TreeNode* temp = root->left;
        root->left = root->right;
        root->right = temp;
        
        // 递归翻转左右子树
        invertTree(root->left);
        invertTree(root->right);
        
        return root;
    }
};

二叉树翻转（镜像）详解：递归一行思维吃透

这道题本质非常简单，但它是理解递归操作树结构的关键模板题。

核心只有一句话：

把每个节点的左右子树交换

---

一、代码在做什么

TreeNode* invertTree(TreeNode* root) {
    if (root == nullptr) {
        return nullptr;
    }
    
    TreeNode* temp = root->left;
    root->left = root->right;
    root->right = temp;
    
    invertTree(root->left);
    invertTree(root->right);
    
    return root;
}

逻辑非常标准，可以拆成三步。

---

二、递归三步理解

第一步：终止条件

if (root == nullptr) return nullptr;

空节点不用处理

---

第二步：当前节点做什么

swap(root->left, root->right);

把左右子树交换（你用 temp 写法也完全正确）

---

第三步：递归子树

invertTree(root->left);
invertTree(root->right);

让左右子树也各自完成翻转

---

三、举个例子

原树：

    4
   / \
  2   7
 / \ / \
1  3 6  9

翻转后：

    4
   / \
  7   2
 / \ / \
9  6 3  1

本质就是每一层都左右对调

---

四、递归本质（重点）

这题最重要的是理解：

你只负责"当前节点交换"，子树交给递归处理

也就是说：

• 你不用管整棵树怎么翻

• 你只管这一层

• 剩下的递归会帮你完成

---

五、时间和空间复杂度

时间复杂度：

O(n)，每个节点访问一次

空间复杂度：

O(h)，递归深度

---

六、非递归写法（层序遍历）

也可以用队列做 BFS：

TreeNode* invertTree(TreeNode* root) {
    if (!root) return root;
    
    queue<TreeNode*> q;
    q.push(root);
    
    while (!q.empty()) {
        TreeNode* node = q.front(); q.pop();
        swap(node->left, node->right);
        
        if (node->left) q.push(node->left);
        if (node->right) q.push(node->right);
    }
    
    return root;
}

---

七、一句话总结

翻转二叉树 = 每个节点交换左右子树 + 递归处理子树

---

2.

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (root == nullptr) return true;
        return isMirror(root->left, root->right);
    }
    
private:
    bool isMirror(TreeNode* left, TreeNode* right) {
        // 两个都为空，对称
        if (left == nullptr && right == nullptr) return true;
        // 一个为空一个不为空，不对称
        if (left == nullptr || right == nullptr) return false;
        // 值不相等，不对称
        if (left->val != right->val) return false;
        
        // 递归检查：左的左 vs 右的右，左的右 vs 右的左
        return isMirror(left->left, right->right) && 
               isMirror(left->right, right->left);
    }
};

对称二叉树详解：镜像递归一眼看透

这道题是二叉树递归的经典题，核心思想其实非常统一：

判断两棵子树是否"镜像对称"

---

一、题目本质

一棵树是对称的，本质就是：

左子树 和 右子树 互为镜像

也就是：

• 左的左 = 右的右

• 左的右 = 右的左

---

二、代码在做什么

bool isSymmetric(TreeNode* root) {
    if (root == nullptr) return true;
    return isMirror(root->left, root->right);
}

从根节点开始，比较左右子树

---

核心函数：

bool isMirror(TreeNode* left, TreeNode* right)

判断两棵树是否互为镜像

---

三、递归核心逻辑

可以理解为四步：

---

第一步：都为空 → 对称

第二步：一个空一个不空 → 不对称

第三步：值不同 → 不对称

第四步：递归判断"镜像结构"

左.left 对比 右.right

左.right 对比 右.left

---

四、举个例子

对称树：

    1
   / \
  2   2
 / \ / \
3  4 4  3

判断过程：

• 2 和 2 ✔

• 3 和 3 ✔

• 4 和 4 ✔

最终返回 true

---

不对称：

    1
   / \
  2   2
   \   \
   3    3

左右结构不匹配 → false

---

五、递归本质（重点）

这题的核心思想是：

把"整棵树对称"转化为"两个子树是否镜像"

你不需要关心整棵树，只需要定义：

函数 isMirror(left, right)

剩下的递归会帮你完成。

---

六、时间和空间复杂度

时间复杂度：

O(n)，每个节点访问一次

空间复杂度：

O(h)，递归深度

---

七、非递归写法（队列）

也可以用队列做：

---

八、一句话总结

对称二叉树 = 判断左右子树是否镜像（交叉递归）