226. 翻转二叉树 LeetCode 热题 HOT 100

目录

• • 过程解析
  • • 一、题目理解
    • [二、前序遍历（根 → 左 → 右）](#二、前序遍历（根 → 左 → 右）)
    • [三、中序遍历（左 → 根 → 右）](#三、中序遍历（左 → 根 → 右）)
    • [四、后序遍历（左 → 右 → 根）](#四、后序遍历（左 → 右 → 根）)
    • 五、层序遍历（按层访问）
  • 代码
  • • C++
    • • 先序遍历
      • 中序遍历
      • 后序遍历
      • 层序遍历
    • C语言

过程解析

一、题目理解

题目要求将一棵二叉树镜像翻转，即对每个节点交换其左右子树位置。

翻转操作核心是：

对当前节点执行：交换左右子树。

不同遍历方法只是操作顺序不同。

---

二、前序遍历（根 → 左 → 右）

• 先访问当前节点，并立即交换左右子树；
• 然后递归处理交换后的左子树和右子树。
• 翻转顺序是自顶向下进行。

---

三、中序遍历（左 → 根 → 右）

• 先递归翻转左子树；
• 回到当前节点时交换左右子树；
• 然后递归处理交换后的右子树。
• 操作在访问根节点时进行，左右指针结构会发生变化。

---

四、后序遍历（左 → 右 → 根）

• 先递归翻转左子树；
• 再递归翻转右子树；
• 最后在当前节点交换左右子树。
• 翻转顺序是自底向上进行。

---

五、层序遍历（按层访问）

• 使用队列，从根节点开始逐层访问；
• 每访问一个节点，立即交换它的左右子树；
• 将子节点加入队列，等待后续访问。
• 翻转顺序是从上到下、按层进行。

代码

C++

先序遍历

/**
 * 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) return nullptr;
        // 先序遍历
        TreeNode *rightTree = root->right;
        root->right = root->left;
        root->left = rightTree;
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};

中序遍历

/**
 * 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) return nullptr;
        // 中序遍历
        invertTree(root->left);
        TreeNode* tmp = root->left;
        root->left = root->right;
        root->right = tmp;
        invertTree(root->left);//左右已经交换了此处仍然使用左子树
        return root;
    }
};

后序遍历

/**
 * 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) return nullptr;
        // 后序遍历
        TreeNode *left = invertTree(root->left);
        TreeNode *right = invertTree(root->right);
        root->right = left;
        root->left = right;
        return root;
    }
};

层序遍历

/**
 * 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) return nullptr;
        // 层序遍历
        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;
    }
};

C语言

略🤣