Leetcode二叉树 part1

Ll13045252982026-02-03 17:35

144. 二叉树的前序遍历

前序遍历顺序：根 → 左 → 右

算法思路：

  1. 沿着左子树一路向下，访问每个节点（push_back），并压栈；
  2. 到达最左后，弹出栈顶，转向其右子树；
  3. 重复直到栈空且当前节点为空。
cpp 复制代码 
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int>res;
        stack<TreeNode*>st;
        TreeNode* cur = root;
        while(cur!=nullptr||!st.empty()){
           while(cur!=nullptr){
            res.push_back(cur->val);
            st.push(cur);
            cur= cur->left;
           }

            cur=st.top();st.pop();
            cur=cur->right;
        }
        return res;
    }
};
cpp 复制代码 
class Solution {
public:
    // 辅助递归函数：对以 cur 为根的子树进行前序遍历
    void traversal(TreeNode* cur, vector<int>& vec) {
        if (cur == nullptr) {  // 终止条件：空节点直接返回
            return;
        }
        vec.push_back(cur->val);    // 访问根节点（"中"）
        traversal(cur->left, vec);  // 递归遍历左子树（"左"）
        traversal(cur->right, vec); // 递归遍历右子树（"右"）
    }

    // 主函数：入口
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;         // 存储遍历结果
        traversal(root, result);    // 启动递归
        return result;
    }
};

94. 二叉树的中序遍历

中序遍历顺序：左 →根 → 右

cpp 复制代码 
class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) return;
        traversal(cur->left, vec);  // 左
        vec.push_back(cur->val);    // 中
        traversal(cur->right, vec); // 右
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};
cpp 复制代码 
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int>res;
        stack<TreeNode*>st;
        TreeNode* cur = root;
        while(cur!=NULL || !st.empty()){
            if(cur!=NULL){
                st.push(cur);
                cur=cur->left;
            }else{
                cur = st.top();
                st.pop();
                result.push_back(cur->val);
                cur=cur->right;
            }
        }
        return res;
    }
};

145. 二叉树的后序遍历

后序遍历顺序：左 → 右→根

cpp 复制代码 
class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) return;
        traversal(cur->left, vec);  // 左
        traversal(cur->right, vec); // 右
        vec.push_back(cur->val);    // 中
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};
cpp 复制代码 
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;
        vector<int> result;
        if (root == NULL) return result;
        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            result.push_back(node->val);
            if (node->left) st.push(node->left); // 相对于前序遍历，这更改一下入栈顺序 （空节点不入栈）
            if (node->right) st.push(node->right); // 空节点不入栈
        }
        reverse(result.begin(), result.end()); // 将结果反转之后就是左右中的顺序了
        return result;
    }
};

102. 二叉树的层序遍历

解题思路

层序遍历要求按树的层级从上到下、每层从左到右 访问节点。这天然适合使用 广度优先搜索 （BFS）来实现，而 BFS 的核心数据结构是 队列（Queue）。

关键挑战在于：如何区分不同层的节点 ？

因为队列在遍历过程中会不断加入子节点，queue.size() 是动态变化的。

解决方法是：

在每一层开始时，记录当前队列的大小（即本层节点数），然后只处理这么多节点。

这样就能确保：

  • 每次外层 while 循环处理完整的一层；
  • 新加入的子节点属于下一层，不会干扰当前层的处理。

最终，我们将每层的结果存入一个 vector<int>，再将所有层的结果组成 vector<vector<int>> 返回。

cpp 复制代码 
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != nullptr) 
            que.push(root);  // 初始化：根节点入队
        
        vector<vector<int>> result;
        
        while (!que.empty()) {
            int size = que.size();  // ✅ 关键：固定当前层的节点数量
            vector<int> vec;        // 存储当前层的值
            
            for (int i = 0; i < size; i++) {  // 只处理本层节点
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);      // 访问当前节点
                
                // 将下一层节点加入队列（不影响当前层的 size）
                if (node->left)  que.push(node->left);
                if (node->right) que.push(node->right);
            }
            
            result.push_back(vec);  // 保存本层结果
        }
        
        return result;
    }
};

107. 二叉树的层序遍历 II

具体步骤：

  1. 使用标准 BFS（队列）进行从上到下的层序遍历；
  2. 将每一层的结果按顺序存入一个 vector<vector<int>>；
  3. 最后对整个结果 reverse，得到自底向上的顺序。
cpp 复制代码 
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result;
        if (!root) return result;

        queue<TreeNode*> que;
        que.push(root);

        while (!que.empty()) {
            int size = que.size();
            vector<int> level;

            for (int i = 0; i < size; ++i) {
                TreeNode* node = que.front();
                que.pop();
                level.push_back(node->val);

                if (node->left)  que.push(node->left);
                if (node->right) que.push(node->right);
            }

            result.push_back(level); // 从上到下收集
        }

        // 关键一步：反转结果
        reverse(result.begin(), result.end());

        return result;
    }
};

199. 二叉树的右视图

右视图 是指从二叉树的右侧看过去能看到的节点值。具体来说，对于每一层，我们只关心最右边的那个节点。

实现步骤：
  1. 使用 BFS（广度优先搜索） 遍历二叉树；
  2. 对于每一层，在遍历过程中记录该层的最后一个节点（即最右边的节点）；
  3. 将每层最右边节点的值加入结果列表。
cpp 复制代码 
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> result;

        if (root) que.push(root);  // 初始化：根节点入队，注意这里应该是 if(root)，而不是 if(!root)
        
        while (!que.empty()) {
            int size = que.size();  // 当前层的节点数
            
            for (int i = 0; i < size; ++i) {
                TreeNode* cur = que.front();
                que.pop();
                
                // 如果是当前层的最后一个节点，则将其值加入结果
                if (i == size - 1) {
                    result.push_back(cur->val);
                }
                
                // 将子节点加入队列
                if (cur->left)  que.push(cur->left);
                if (cur->right) que.push(cur->right);
            }
        }

        return result;
    }
};

637. 二叉树的层平均值

使用 BFS 进行层序遍历。

对每一层，先遍历所有节点并累加它们的值，同时将子节点加入队列；

遍历完当前层后，用总和除以节点数得到平均值，并加入结果。

这样保证了每层的统计是完整且独立的。

cpp 复制代码 
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> result;
        if (!root) return result;

        queue<TreeNode*> que;
        que.push(root);

        while (!que.empty()) {
            int size = que.size();
            double sum = 0.0;

            // 遍历当前层的所有节点
            for (int i = 0; i < size; ++i) {
                TreeNode* node = que.front();
                que.pop();
                sum += node->val;

                if (node->left)  que.push(node->left);
                if (node->right) que.push(node->right);
            }

            // 整层处理完毕，计算平均值
            result.push_back(sum / size);
        }

        return result;
    }
};

429. N 叉树的层序遍历

cpp 复制代码 
class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*>que;
        if(root)que.push(root);
        vector<vector<int>>result;
        while(!que.empty()){
            vector<int>res;
            int size = que.size();

            for(int i = 0;i<size;i++){
                Node* cur = que.front();
                que.pop();
                res.push_back(cur->val);
                for(Node*  child:cur->children){
                    if(child)que.push(child);
                }
            }
            result.push_back(res);
        }
        
        return result;
    }
};

515. 在每个树行中找最大值

cpp 复制代码 
class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*>que;
        if(root)que.push(root);
        vector<int> result;
        while(!que.empty()){
            int size = que.size();
            int tmp= INT_MIN; ;
            for(int i = 0;i<size;i++){
                TreeNode* node = que.front();
                que.pop();
                tmp = max(tmp, node->val); // 更简洁安全
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);
            }
            result.push_back(tmp);
        }
        return result;
    }
};

116. 填充每个节点的下一个右侧节点指针

解题思路回顾

题目要求：将二叉树每一层的节点，从左到右用 next 指针连接起来，每层最后一个节点的 next 为 nullptr。

你的核心思想是：

  1. 使用队列进行标准层序遍历；
  2. 在每一层中，通过 i == size - 1 判断是否为当前层最后一个节点 ；
    • 如果是 → node->next = nullptr；
    • 否则 → node->next = que.front()（此时队头正是当前层的下一个节点）；
  3. 同时将子节点入队，供下一层使用。
cpp 复制代码 
class Solution {
public:
    Node* connect(Node* root) {
        if (!root) return root;

        queue<Node*> q;
        q.push(root);

        while (!q.empty()) {
            int size = q.size();
            for (int i = 0; i < size; ++i) {
                Node* node = q.front();
                q.pop();

                // 连接 next 指针
                if (i == size - 1) {
                    node->next = nullptr;
                } else {
                    node->next = q.front(); // 当前层下一个节点
                }

                // 加入下一层节点
                if (node->left)  q.push(node->left);
                if (node->right) q.push(node->right);
            }
        }
        return root;
    }
};

104. 二叉树的最大深度

解题思路

二叉树的最大深度 = 从根节点到最远叶子节点的最长路径上的节点数。

使用 BFS（广度优先搜索）时：

  • 每完成一层的遍历，深度 +1；
  • 当队列为空时，说明所有层都已处理完毕；
  • 最终的 depth 就是树的高度。

这与"层序遍历"天然契合------遍历了多少层，深度就是多少。

cpp 复制代码 
class Solution {
public:
    int maxDepth(TreeNode* root) {
      queue<TreeNode*>que;
      if(root)que.push(root);
      int depth=0;
    
        while(!que.empty()){
            int size = que.size();
            depth++;

            for(int i =0;i<size;i++){
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return depth;
    }
};

递归法

cpp 复制代码 
class Solution {
public:
    int getdepth(TreeNode* node) {
        if (node == NULL) return 0;
        int leftdepth = getdepth(node->left);       // 左
        int rightdepth = getdepth(node->right);     // 右
        int depth = 1 + max(leftdepth, rightdepth); // 中
        return depth;
    }
    int maxDepth(TreeNode* root) {
        return getdepth(root);
    }
};

111. 二叉树的最小深度

解题思路

最小深度 的定义是：从根节点到最近叶子节点的最短路径上的节点数。

📌 注意：叶子节点是指没有左右子节点的节点 （left == nullptr && right == nullptr）。

由于 BFS 是按层遍历 的，一旦遇到第一个叶子节点，当前层数就是最小深度，可以立即返回------这是 BFS 相比 DFS 的巨大优势（DFS 需要遍历整棵树才能确定最小值）。

cpp 复制代码 
class Solution {
public:
    int minDepth(TreeNode* root) {
        if (!root) return 0; // 空树深度为 0
        queue<TreeNode*>q;
        q.push(root);
        int depth = 0;
        
        while(!q.empty()){
            int size=q.size();//当前层节点
            depth++;
            for(int i=0; i<size;i++){
                TreeNode* node = q.front();q.pop();
                
                if(!node->left&&!node->right)return depth;
                if(node->left)q.push(node->left);
                if(node->right)q.push(node->right);
            }
        }
        return depth;
    }
};

递归法

cpp 复制代码 
class Solution {
public:
    int getDepth(TreeNode* node) {
        if (node == NULL) return 0;
        int leftDepth = getDepth(node->left);           // 左
        int rightDepth = getDepth(node->right);         // 右
                                                        // 中
        // 当一个左子树为空，右不为空，这时并不是最低点
        if (node->left == NULL && node->right != NULL) { 
            return 1 + rightDepth;
        }   
        // 当一个右子树为空，左不为空，这时并不是最低点
        if (node->left != NULL && node->right == NULL) { 
            return 1 + leftDepth;
        }
        int result = 1 + min(leftDepth, rightDepth);
        return result;
    }

    int minDepth(TreeNode* root) {
        return getDepth(root);
    }
};

226. 翻转二叉树

思路

我们之前介绍的都是各种方式遍历二叉树，这次要翻转了，感觉还是有点懵逼。

这得怎么翻转呢？

如果要从整个树来看，翻转还真的挺复杂，整个树以中间分割线进行翻转

可以发现想要翻转它，其实就把每一个节点的左右孩子交换一下就可以了。

关键在于遍历顺序，前中后序应该选哪一种遍历顺序？ （一些同学这道题都过了，但是不知道自己用的是什么顺序）

遍历的过程中去翻转每一个节点的左右孩子就可以达到整体翻转的效果。

注意只要把每一个节点的左右孩子翻转一下，就可以达到整体翻转的效果

这道题目使用前序遍历和后序遍历都可以，唯独中序遍历不方便，因为中序遍历会把某些节点的左右孩子翻转了两次！建议拿纸画一画，就理解了

那么层序遍历可以不可以呢？依然可以的！只要把每一个节点的左右孩子翻转一下的遍历方式都是可以的！

递归法

cpp 复制代码 
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root==NULL)return root;
        swap(root->left,root->right);
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};

迭代法

深度优先遍历
cpp 复制代码 
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        stack<TreeNode*> st;
        st.push(root);
        while(!st.empty()) {
            TreeNode* node = st.top();              // 中
            st.pop();
            swap(node->left, node->right);
            if(node->right) st.push(node->right);   // 右
            if(node->left) st.push(node->left);     // 左
        }
        return root;
    }
};

层序遍历

cpp 复制代码 
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                swap(node->left, node->right); // 节点处理
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;
    }
};

101. 对称二叉树

思路

首先想清楚，判断对称二叉树要比较的是哪两个节点，要比较的可不是左右节点！

对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。

那么如何比较呢？

比较的是两个子树的里侧和外侧的元素是否相等。

递归法

cpp 复制代码 
class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right) {
        // 首先排除空节点的情况
        if (left == NULL && right != NULL) return false;
        else if (left != NULL && right == NULL) return false;
        else if (left == NULL && right == NULL) return true;
        // 排除了空节点，再排除数值不相同的情况
        else if (left->val != right->val) return false;

        // 此时就是：左右节点都不为空，且数值相同的情况
        // 此时才做递归，做下一层的判断
        bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
        bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
        bool isSame = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）
        return isSame;

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

迭代法

cpp 复制代码 
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        queue<TreeNode*> que;
        que.push(root->left);   // 将左子树头结点加入队列
        que.push(root->right);  // 将右子树头结点加入队列
        
        while (!que.empty()) {  // 接下来就要判断这两个树是否相互翻转
            TreeNode* leftNode = que.front(); que.pop();
            TreeNode* rightNode = que.front(); que.pop();
            if (!leftNode && !rightNode) {  // 左节点为空、右节点为空，此时说明是对称的
                continue;
            }

            // 左右一个节点不为空，或者都不为空但数值不相同，返回false
            if ((!leftNode || !rightNode || (leftNode->val != rightNode->val))) {
                return false;
            }
            que.push(leftNode->left);   // 加入左节点左孩子
            que.push(rightNode->right); // 加入右节点右孩子
            que.push(leftNode->right);  // 加入左节点右孩子
            que.push(rightNode->left);  // 加入右节点左孩子
        }
        return true;
    }
};
使用栈

细心的话，其实可以发现，这个迭代法，其实是把左右两个子树要比较的元素顺序放进一个容器，然后成对成对的取出来进行比较，那么其实使用栈也是可以的。

cpp 复制代码 
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        stack<TreeNode*> st; // 这里改成了栈
        st.push(root->left);
        st.push(root->right);
        while (!st.empty()) {
            TreeNode* rightNode = st.top(); st.pop();
            TreeNode* leftNode = st.top(); st.pop();
            if (!leftNode && !rightNode) {
                continue;
            }
            if ((!leftNode || !rightNode || (leftNode->val != rightNode->val))) {
                return false;
            }
            st.push(leftNode->left);
            st.push(rightNode->right);
            st.push(leftNode->right);
            st.push(rightNode->left);
        }
        return true;
    }
};
相关推荐
鹿角片ljp2 小时前
力扣9.回文数-转字符双指针和反转数字
java·数据结构·算法
热爱编程的小刘2 小时前
Lesson04---类与对象(下篇)
开发语言·c++·算法
有代理ip2 小时前
成功请求的密码：HTTP 2 开头响应码深度解析
java·大数据·python·算法·php
YYuCChi3 小时前
代码随想录算法训练营第三十四天 | 62.不同路径、63.不同路径||
算法
小明同学013 小时前
[C++进阶] 深度解析AVLTree
c++·算法·visualstudio
CoderCodingNo3 小时前
【GESP】C++五级练习题 luogu-P1031 [NOIP 2002 提高组] 均分纸牌
开发语言·c++·算法
梯度下降中4 小时前
求职面试中的线代知识总结
人工智能·线性代数·算法·机器学习
SmartBrain4 小时前
OCR 模型在医疗场景的选型研究
人工智能·算法·语言模型·架构·aigc·ocr
梵刹古音4 小时前
【C语言】 跳转语句
c语言·开发语言·算法
热门推荐
01GitHub 镜像站点02Clawdbot 中文汉化版 接入微信、飞书03OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)04Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services05Claude Code Skills 实用使用手册06OpenClaw部署与配置教程：在Mac mini上接入国产大模型与飞书07UV安装并设置国内源08在Trae中使用Pencil MCP09Linux下V2Ray安装配置指南10Vue-skills的中文文档