1.
cpp
/**
* 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;
}
};二叉树翻转（镜像）详解：递归一行思维吃透
这道题本质非常简单，但它是理解递归操作树结构的关键模板题。
核心只有一句话：
把每个节点的左右子树交换
一、代码在做什么
cpp
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：
cpp
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.
cpp
/**
* 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);
}
};对称二叉树详解：镜像递归一眼看透
这道题是二叉树递归的经典题，核心思想其实非常统一：
判断两棵子树是否"镜像对称"
一、题目本质
一棵树是对称的，本质就是：
左子树 和 右子树 互为镜像
也就是：
-
左的左 = 右的右
-
左的右 = 右的左
二、代码在做什么
cpp
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)，递归深度
七、非递归写法（队列）
也可以用队列做：
八、一句话总结
对称二叉树 = 判断左右子树是否镜像（交叉递归）