代码随想录算法训练营第十六天_第六章_二叉树 | 104.二叉树的最大深度 559.n叉树的最大深度、111.二叉树的最小深度、222.完全二叉树的节点个数

原创 已于 2025-11-04 10:51:04 修改 · 193 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#leetcode
于 2023-01-09 11:18:53 首次发布
文章介绍了如何使用递归和迭代方法计算二叉树的最大深度和最小深度，包括后序和前序遍历的策略。同时，对于完全二叉树，文章提供了计算节点数量的方法，特别关注满二叉树的情况。

LeetCode 104.二叉树的最大深度

⭐高度👆 vs 深度👇：

  • 二叉树节点的高度👆（后序）：指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始）
  • 二叉树节点的深度👇（前序）：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）

视频讲解https://www.bilibili.com/video/BV1Gd4y1V75u/?vd_source=f98f2942b3c4cafea8907a325fc56a48文章讲解https://programmercarl.com/0104.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E5%A4%A7%E6%B7%B1%E5%BA%A6.html

根节点的高度就是二叉树的最大深度

  • 思路：
    • 通过后序求根节点的高度：（父节点高度 = 子节点高度 + 1）
    1. 确定递归函数的参数和返回值：根节点        int
    2. 确定终止条件：如果为空节点的话，就返回0，表示高度为0。
    3. 确定单层递归的逻辑：先求它的左子树的高度，再求右子树的高度，最后左右子树高度取大 再+1 （加1是因为算上当前中间节点）就是当前子树的高度。
    • 通过前序求根节点的深度：（子节点深度 = 父节点深度 + 1）
    1. 确定递归函数的参数和返回值：(Treenode* node, int depth)        void
    2. 确定终止条件：如果为叶子节点的话，就返回。
    3. 确定单层递归的逻辑：左孩子非空，则求左孩子深度；右孩子非空，则求右孩子深度。父节点深度为 depth，故 depth + 1 就是当前节点的深度。
  • 代码： 
// 后序
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);
    }
};
// 后序：精简版
class solution {
public:
    int maxdepth(Treenode* root) {
        if (root == null) return 0;
        return 1 + max(maxdepth(root->left), maxdepth(root->right));
    }
};

// 前序
class solution {
public:
    int result;
    void getdepth(Treenode* node, int depth) {
        result = depth > result ? depth : result; // 中

        if (node->left == NULL && node->right == NULL) return ;

        if (node->left) { // 左
            depth++;    // 深度+1
            getdepth(node->left, depth);
            depth--;    // 回溯，深度-1
        }
        if (node->right) { // 右
            depth++;    // 深度+1
            getdepth(node->right, depth);
            depth--;    // 回溯，深度-1
        }
        return ;
    }
    int maxdepth(Treenode* root) {
        result = 0;
        if (root == NULL) return result;
        getdepth(root, 1);
        return result;
    }
};
// 前序：精简版
class solution {
public:
    int result;
    // node为当前处理节点（非空），depth为node的深度
    void getdepth(Treenode* node, int depth) {
        result = depth > result ? depth : result; // 中
        if (node->left == NULL && node->right == NULL) return ;
        if (node->left) { // 左
            getdepth(node->left, depth + 1);
        }
        if (node->right) { // 右
            getdepth(node->right, depth + 1);
        }
        return ;
    }
    int maxdepth(Treenode* root) {
        result = 0;
        if (root == 0) return result;
        // 根节点（非空）深度为1
        getdepth(root, 1);
        return result;
    }
};
// 迭代：层序
class solution {
public:
    int maxdepth(Treenode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<Treenode*> que;
        que.push(root);
        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;
    }
};

 相关题目：

LeetCode 559.n叉树的最大深度

// 递归法（后序）
class solution {
public:
    int maxdepth(node* root) {
        if (root == 0) return 0;
        int depth = 0;
        for (int i = 0; i < root->children.size(); i++) {
            depth = max (depth, maxdepth(root->children[i]));
        }
        return depth + 1;
    }
};
// 前序
class Solution {
public:
    int result;
    // depth为node父节点的深度
    void getHeight(Node* node, int depth) {
        if (node == NULL) return;
        // node深度：depth + 1
        result = (depth + 1) > result ? (depth + 1) : result;
        for (int i = 0; i < node->children.size(); ++i) {
            getHeight(node->children[i], depth + 1);
        }
    }
    int maxDepth(Node* root) {
        result = 0;
        getHeight(root, 0);
        return result;
    }
};
// 迭代法（层序）
class solution {
public:
    int maxdepth(node* root) {
        queue<node*> que;
        if (root != NULL) que.push(root);
        int depth = 0;
        while (!que.empty()) {
            int size = que.size();
            depth++; // 记录深度
            for (int i = 0; i < size; i++) {
                node* node = que.front();
                que.pop();
                for (int j = 0; j < node->children.size(); j++) {
                    if (node->children[j]) que.push(node->children[j]);
                }
            }
        }
        return depth;
    }
};

LeetCode 111.二叉树的最小深度

        最小深度是从根节点到最近叶子节点的最短路径上的节点数量 

视频讲解https://www.bilibili.com/video/BV1QD4y1B7e2文章讲解https://programmercarl.com/0111.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E5%B0%8F%E6%B7%B1%E5%BA%A6.html#%E9%80%92%E5%BD%92%E6%B3%95

111.二叉树的最小深度

  • 思路：根节点到叶子节点的最小距离
    • 后序：左右子树高度取小 → 以中节点为子树的最小深度？
    1. 递归函数参数、返回值：(Treenode* node)        返回值 int
    2. 确定终止条件：如果为空节点的话，就返回0，表示高度为0。
    3. 确定单层递归的逻辑：（若子树一空一非空，返回非空子树最小深度 +1）先求它的左子树的最小深度，再求右子树的最小深度，最后左右子树最小深度取小 再+1 （加1是因为算上当前中间节点）就是当前子树的最小深度。
    • 前序：
    1. 确定递归函数的参数和返回值：(Treenode* node, int depth)        void
    2. 确定终止条件：如果为叶子节点的话，记录结果，返回。
    3. 确定单层递归的逻辑：左孩子非空，则求左孩子最小深度；右孩子非空，则求右孩子最小深度。父节点深度为 depth，故 depth + 1 就是当前节点的深度。
  • 代码：
// 后序
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);
    }
};
// 后序：精简版
class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == NULL) return 0;
        if (root->left == NULL && root->right != NULL) {
            return 1 + minDepth(root->right);
        }
        if (root->left != NULL && root->right == NULL) {
            return 1 + minDepth(root->left);
        }
        return 1 + min(minDepth(root->left), minDepth(root->right));
    }
};
// 前序
class Solution {
private:
    int result;
    void getdepth(TreeNode* node, int depth) {
        if (node->left == NULL && node->right == NULL) {
            result = min(depth, result);  
            return;
        }
        // 中 只不过中没有处理的逻辑
        if (node->left) { // 左
            getdepth(node->left, depth + 1);
        }
        if (node->right) { // 右
            getdepth(node->right, depth + 1);
        }
        return ;
    }

public:
    int minDepth(TreeNode* root) {
        if (root == NULL) return 0;
        result = INT_MAX;
        getdepth(root, 1);
        return result;
    }
};
// 迭代：层序
class Solution {
public:

    int minDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        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);
                if (!node->left && !node->right) { // 当左右孩子都为空的时候，说明是最低点的一层了，退出
                    return depth;
                }
            }
        }
        return depth;
    }
};

LeetCode 222.完全二叉树的节点个数

⭐完全二叉树：找满二叉树，利用公式计算节点个数：2^深度 - 1
视频讲解https://www.bilibili.com/video/BV1eW4y1B7pD文章讲解https://programmercarl.com/0222.%E5%AE%8C%E5%85%A8%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E8%8A%82%E7%82%B9%E4%B8%AA%E6%95%B0.html

  • 思路：
    • 普通二叉树：左子树节点个数 + 右子树节点个数 + 1        时间复杂度：O(n)
    • 完全二叉树：前序遍历找构成满二叉树的子树

222.完全二叉树的节点个数

前提：完全二叉树，每层从左到右节点连续，故可以直接判断两侧节点数，若相等则为满二叉树

  1. 参数、返回值：
  2. 终止条件： 
    if (root == nullptr) return 0; 
// 开始根据左深度和右深度是否相同来判断该子树是不是满二叉树
TreeNode* left = root->left;
TreeNode* right = root->right;
int leftDepth = 0, rightDepth = 0; // 这里初始为0是有目的的，为了下面求指数方便
while (left) {  // 求左子树深度
    left = left->left;
    leftDepth++;
}
while (right) { // 求右子树深度
    right = right->right;
    rightDepth++;
}
if (leftDepth == rightDepth) {
    return (2 << leftDepth) - 1; // 注意(2<<1) 相当于2^2，返回满足满二叉树的子树节点数量
}
  3. 单层递归逻辑：左子树节点个数 + 右子树节点个数 + 1
  • 代码：
// 适用于普通二叉树
// 递归
class Solution {
private:
    int getNodesNum(TreeNode* cur) {
        if (cur == NULL) return 0;
        int leftNum = getNodesNum(cur->left);      // 左
        int rightNum = getNodesNum(cur->right);    // 右
        int treeNum = leftNum + rightNum + 1;      // 中
        return treeNum;
    }
public:
    int countNodes(TreeNode* root) {
        return getNodesNum(root);
    }
};
// 递归：精简版
class Solution {
public:
    int countNodes(TreeNode* root) {
        if (root == NULL) return 0;
        return 1 + countNodes(root->left) + countNodes(root->right);
    }
};

// 迭代
class Solution {
public:
    int countNodes(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        int result = 0;
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                result++;   // 记录节点数量
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return result;
    }
};

// 适用于完全二叉树
class Solution {
public:
    int countNodes(TreeNode* root) {
        if (root == nullptr) return 0;
        TreeNode* left = root->left;
        TreeNode* right = root->right;
        int leftDepth = 0, rightDepth = 0; // 这里初始为0是有目的的，为了下面求指数方便
        while (left) {  // 求左子树深度
            left = left->left;
            leftDepth++;
        }
        while (right) { // 求右子树深度
            right = right->right;
            rightDepth++;
        }
        if (leftDepth == rightDepth) {
            return (2 << leftDepth) - 1; // 注意(2<<1) 相当于2^2，所以leftDepth初始为0
        }
        return countNodes(root->left) + countNodes(root->right) + 1;
    }
};

注：2 << i - 1        2 左移 i - 1 位，相当于 2 * 2 * ... * 2        i - 1 个 2

即 2 ^ i 

Jane_10358
关注
代码随想录算法训练营第十六天，第六章 二叉树 | 104.二叉树的最大深度 559.n叉树的最大深度 111.二叉树的最小深度 222.完全二叉树的节点个数
aabbccas的博客
11-13 266
LeetCode
代码随想录算法训练营第十六天| 第六章二叉树：104.二叉树的最大深度 559.n叉树的最大深度，111.二叉树的最小深度，222.完全二叉树的节点个数（python）
weixin_40894831的博客
12-05 92
104.二叉树的最大深度递归法，559.n叉树的最大深度递归解法，111.二叉树的最小深度，222.完全二叉树的节点个数
代码随想录算法训练营第十六天|104. 二叉树的最大深度、559. N 叉树的最大深度、111. 二叉树的最小深度、222. 完全二叉树的节点个数
qq_63241956的博客
09-02 75
第六章二叉树part03给定一个二叉树root，返回其最大深度。二叉树的是指从根节点到最远叶子节点的最长路径上的节点数。
LeetCode 380 O(1) 时间插入、删除和获取随机元素
weixin_66162442的博客
06-20 161
摘要： LeetCode 380题要求实现一个支持O(1)时间插入、删除和随机获取元素的数据结构。核心解法采用"数组+哈希表"组合，数组存储元素实现随机访问，哈希表记录元素位置实现快速查找。删除时通过将末尾元素覆盖待删位置来避免数组移位，确保操作高效性。代码实现中需注意边界条件处理（如删除末尾元素时）和哈希表与数组的同步更新。该方案三大操作均满足O(1)时间复杂度，空间复杂度O(N)，是典型的空间换时间策略，关键在于利用哈希表维护元素位置信息与数组随机访问特性的巧妙结合。
LeetCode--491.递增子序列（回溯算法）
Coding...
06-16 175
解题思路 这道题要求找出数组中所有不同的递增子序列，序列长度至少为2。由于数组未排序且可能包含重复元素，需要使用回溯算法结合剪枝策略来高效解决问题。 关键点： 回溯框架：通过递归遍历所有可能的子序列组合 树层去重：使用HashSet记录当前层已使用的数字，避免重复计算 递增判断：确保新加入数字不小于序列最后一个数字 结果收集：当路径长度≥2时保存结果 实现细节： 不排序数组，保持原始顺序 每层递归维护独立的used集合，防止同层重复 及时剪枝，跳过不满足递增条件的数字 注意回溯时要恢复状态 该算法时间复杂度
leetcode 2130. 链表最大孪生和 中等
2401_88085478的博客
06-15 261
节点 0 和节点 1 分别是节点 3 和 2 的孪生节点。链表中只有一对孪生节点，孪生和为 1 + 100000 = 100001。- 节点 0 是节点 3 的孪生节点，孪生和为 4 + 3 = 7。- 节点 1 是节点 2 的孪生节点，孪生和为 2 + 2 = 4。所以，最大孪生和为 max(7, 4) = 7。定义为一个节点和它孪生节点两者值之和。给你一个长度为偶数的链表的头节点。所以，链表的最大孪生和是 6。开始）的孪生节点为第。链表中没有其他孪生节点。
链表算法上篇：LeetCode 206/234/141/142/160/21 题解与易错点
2401_87961121的博客
06-15 635
这篇文章整理链表算法的六道经典题，帮你建立从"能写出来"到"不犯低级错误"的认知闭环。刷链表题最大的坑不是思路，是细节：引用和值傻傻分不清、循环中途空指针、计数差一个……这些错误我都踩过，全记在这里。│ 错误类型 │ 出现题目 │ 根因 ││ 修改 next 前没存 │ 206/234 │ 两变量同一对象 ││ cnt 初始值为 1 │ 234 │ 循环边界差一 ││ 用 == 比较值 │ 234 │ 混淆地址和值比较 ││ 循环中途空指针 │ 141 │ while 只管入口 │。
《LeetCode 200 FloodFill 岛屿数量DFS解法》
2601_95366422的博客
06-15 282
LeetCode200 岛屿数量
LeetCode 3264.K次乘运算后的最终数组I
tus00000的博客
06-17 238
如果nums的大小为n，数组中最大值为U，multiplier为m，则此算法时间复杂度为O(nlognlog。输入：nums = [2,1,3,5,6], k = 5, multiplier = 2。输入：nums = [1,2], k = 3, multiplier = 4。1 次操作后 [2, 2, 3, 5, 6]2 次操作后 [4, 2, 3, 5, 6]3 次操作后 [4, 4, 3, 5, 6]4 次操作后 [4, 4, 6, 5, 6]5 次操作后 [8, 4, 6, 5, 6]
《LeetCode 103 二叉树的锯齿形层序遍历 队列宽搜BFS解法》
2601_95366422的博客
06-21 226
LeetCode 103 二叉树的锯齿形层序遍历是队列宽搜（BFS）在树结构上的经典变式应用。本题在普通层序遍历的基础上，巧妙引入一个 方向标志位，逐层切换输出方向
＜leetCode回文题的多种解法＞转战github https://github.com/WinXi27
ideal-cs-pku
06-20 62
本文总结了5道回文相关的LeetCode题目及解法：9.回文数、125.验证回文串、234.回文链表、266.回文排列和680.验证回文串II。主要使用双指针技术，配合字符串处理、链表反转和哈希表等方法。其中234题通过快慢指针找中点后反转链表进行判断，680题允许最多删除一个字符的情况下验证回文性。所有解法均通过代码实现并保证AC。
【leetcode】121.买卖股票的最佳时机js/c++
2402_83244812的博客
06-16 391
摘要：该问题采用贪心算法解决股票买卖最佳时机问题。通过维护当前最小买入价和计算当前卖出利润，更新最大利润值。JavaScript实现遍历数组时动态更新最小价格和最大利润。类似地，C++版本使用迭代器跟踪买入点和遍历卖出点，当发现更低价格时更新买入点，并始终记录最大利润值。两种实现均只需一次遍历，时间复杂度为O(n)。
leetcode3612 用特殊操作处理字符串I
2301_80296866的博客
06-16 56
遍历字符串，按照题目要求进行处理就可。
【每日一题】LeetCode 49. 字母异位词分组 TypeScript
qq_69682052的博客
06-20 219
如何获得哈希表里的所有value，并以数组的形式返回 Array.from(map.values())或[...map.values()]如何把字符串分割排序后合并 str.split('').sort().join('')给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。②同样字母组合的字符串作为键，不同的str作为值；①把每个字符串分割、排序、合并成字符串；
LeetCode--90.子集II（回溯算法）
Coding...
06-16 237
摘要 该算法解决子集II问题，用于生成包含重复元素数组的所有不重复子集。核心思路是回溯算法配合剪枝策略，通过排序数组和标记使用状态来避免重复子集。具体步骤：1) 对数组排序使相同元素相邻；2) 使用回溯法递归构建子集；3) 通过检查与前一个元素的相等性及使用状态(used数组)来跳过同一层的重复元素。时间复杂度为O(n*2^n)，空间复杂度为O(n)。示例：输入[1,2,2]输出[[],[1],[1,2],[1,2,2],[2],[2,2]]。
LeetCode 每日一题笔记 日期：2026.06.19 题目：1732. 找到最高海拔
最新发布
sheeta1998的博客
06-21 192
核心：前缀和遍历，实时维护全局最大值；Math.max替代if条件判断，精简代码，减少分支；关键点：初始最高海拔必须设为0，因为起点海拔为0，全程可能无上坡。
【每日一题】LeetCode 148. 排序链表 TypeScript
qq_69682052的博客
06-15 269
1.找出中心节点，分成两段链表。2.将两段链表进行升序排序。
LeetCode 每日一题 2026/6/15-2026/6/21
AlphaTao的博客
06-21 35
记录了初步解题思路 以及本地实现代码；并不一定为最优 也希望大家能一起探讨 一起进步
LeetCode--1584. 连接所有点的最小费用（最小生成树/Prim算法/Kruskal算法）
Coding...
06-14 921
摘要 该问题要求计算连接平面上多个点的最小总费用，其中连接费用为两点间的曼哈顿距离。解题核心是构建最小生成树(MST)，可采用Kruskal或Prim算法。Kruskal通过排序边并查集合并连通分量，时间复杂度O(n² logn)；Prim通过维护距离数组逐步扩展生成树，时间复杂度O(n²)。两种方法均能有效解决该问题，其中Prim更适合稠密图。代码实现展示了两种算法的具体步骤，包括边排序、并查集操作和距离更新等关键环节。
LeetCode--131.分割回文串（回溯算法）
Coding...
06-15 219
摘要 该题要求将字符串分割成多个回文子串，返回所有可能的分割方案。解题使用回溯算法，从字符串起始位置开始，逐步尝试所有可能的切割点。当发现某个子串是回文时，将其加入当前路径，并递归处理剩余部分。处理完成后回溯撤销选择。使用双指针法判断子串是否为回文。最终所有有效分割方案会被收集到结果列表中。时间复杂度为O(n*2^n)，空间复杂度为O(n^2)用于存储结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值