二叉树：leetcode 104.二叉树的最大深度、111.二叉树的最小深度、222.完全二叉树的节点个数

最新推荐文章于 2024-07-24 22:13:43 发布
最新推荐文章于 2024-07-24 22:13:43 发布
阅读量88 收藏
点赞数
文章标签： leetcode 算法 数据结构 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52097561/article/details/128796430
版权

leetcode 104.二叉树的最大深度

leetcode 111.二叉树的最小深度

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

leetcode 104.二叉树的最大深度

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

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

而根节点的高度就是二叉树的最大深度。在二叉树中求高度使用的是后序遍历，因为求高度是从下往上去计数，后序（左右中）的处理逻辑放在最后一步，我们可以把叶子节点的高度返回给其父节点，那么父节点就知道其孩子的高度，其本身的高度只需做一个+1的操作即可，所以要使用后序遍历。求深度使用的是前序遍历（中左右），将处理逻辑放在第一步，二叉树往下遍历一次深度就+1，所以使用前序遍历。

递归法

本题使用后序遍历或前序遍历均可完成。

递归三部曲：

  1. 确定递归函数的参数和返回值

参数就是传入树的根节点，返回就返回这棵树的深度，所以返回值为int类型。

int getHeight(TreeNode* node)

  1. 确定终止条件

遍历的节点遇到空节点就返回0，表示此时高度为0。

if(node == NULL) return 0;

  1. 确定单层递归的逻辑

先求它的左子树的高度，再求右子树的高度，最后取左右高度最大的数值再+1 （加1是因为算上当前中间节点）就是目前节点为根节点的树的高度。

int leftHeight = getHeight(node->left);            // 左
int rightHeight = getHeight(node->right);          // 右
int Height = 1 + max(leftHeight, rightHeight);     // 中
return Height;

所以代码求得根节点的最大高度，也就是二叉树的最大深度。

整体代码如下：

/**
 * 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:
    int getHeight(TreeNode* node){
        if(node == NULL) return 0;
        int leftHeight = getHeight(node->left);
        int rightHeight = getHeight(node->right);
        int Height = 1 + max(leftHeight, rightHeight);
        return Height;
    }
    int maxDepth(TreeNode* root) {
        return getHeight(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 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 111.二叉树的最小深度

本题依然是前序遍历和后序遍历都可以，前序求的是深度，后序求的是高度。

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

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

那么使用后序遍历，其实求的是根节点到叶子节点的最小距离，就是求高度的过程，不过这个最小距离 也同样是最小深度。

本题还有一个误区，在处理节点的过程中，最大深度很容易理解，最小深度就不那么好理解，如图：

这就重新审题了，题目中说的是：最小深度是从根节点到最近叶子节点的最短路径上的节点数量。注意是叶子节点。

什么是叶子节点，左右孩子都为空的节点才是叶子节点！

递归法

递归三部曲：

  1. 确定递归函数的参数和返回值

参数为要传入的二叉树根节点，返回的是int类型的深度。

int getHeight(TreeNode* node)

  1. 确定终止条件

终止条件也是遇到空节点返回0，表示当前节点的高度为0。

if(node == NULL) return 0;

  1. 确定单层递归的逻辑

int leftHeight = getHeight(node->left);
int rightHeight = getHeight(node->right);
int result = 1 + min(leftHeight, rightHeight);
return result;

上面这样写是错的，上图中左为空，右不为空的节点不是叶子节点，不是最小高度。

所以，如果左子树为空，右子树不为空，说明最小深度是 1 + 右子树的深度。

反之，右子树为空，左子树不为空，最小深度是 1 + 左子树的深度。 最后如果左右子树都不为空，返回左右子树深度最小值 + 1 。

正确代码如下：

int leftHeight = getHeight(node->left);
int rightHeight = getHeight(node->right);
if(node->left == NULL && node->right != NULL)
    return 1 + rightHeight;
if(node->left != NULL && node->right == NULL)
    return 1 + leftHeight;
int result = 1 + min(leftHeight, rightHeight);
return result;

遍历的顺序为后序（左右中），可以看出：求二叉树的最小深度和求二叉树的最大深度的差别主要在于处理左右孩子不为空的逻辑。

整体递归代码如下：

/**
 * 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:
    int getHeight(TreeNode* node){
        if(node == NULL) return 0;
        int leftHeight = getHeight(node->left);
        int rightHeight = getHeight(node->right);;
        if(node->left == NULL && node->right != NULL)
            return 1 + rightHeight;
        if(node->left != NULL && node->right != NULL)
            return 1 + leftHeight;
        int result = 1 + min(leftHeight, rightHeight);
        return result;  
    }
    int minDepth(TreeNode* root) {
        return getHeight(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.完全二叉树的节点个数

可以使用普通二叉树的求法以及利用完全二叉树性质的求法。

普通二叉树

递归法

这道题目的递归法和求二叉树的深度写法类似， 而迭代法（层序遍历）遍历模板稍稍修改一下，记录遍历的节点数量就可以了。

递归遍历的顺序依然是后序（左右中）。

递归三部曲：

  1. 确定递归函数的参数和返回值

参数就是传入树的根节点，返回就返回以该节点为根节点二叉树的节点数量，所以返回值为int类型。

int getNum(TreeNode* node)

  1. 确定终止条件

如果为空节点的话，就返回0，表示节点数为0。

if(node == NULL) return 0;

  1. 确定单层递归的逻辑

先求它的左子树的节点数量，再求右子树的节点数量，最后取总和再加一 （加1是因为算上当前中间节点）就是目前节点为根节点的节点数量。

int leftNum = getNum(node->left);
int rightNum = getNUm(node->right);
int result = leftNum + rightNum + 1;
return result;

整体代码如下：

/**
 * 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:
    int getNum(TreeNode* node){
        if(node == NULL) return 0;
        int leftNum = getNum(node->left);
        int rightNum = getNum(node->right);
        int result = leftNum + rightNum + 1;
        return result;
    }
    int countNodes(TreeNode* root) {
        return getNum(root);
    }
};

精简代码如下：

class Solution {
public:
    int countNodes(TreeNode* root) {
        if(root == NULL) return 0;
        return 1 + countNodes(root->left) + countNodes(root->right);
    }
};

  • 时间复杂度：O(n)

  • 空间复杂度：O(logn)，算上了递归系统栈占用的空间

迭代法

同样是层序遍历的模板题，代码如下：

/**
 * 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:
    int countNodes(TreeNode* root) {
        if(root == NULL) return 0;
        int result = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            for(int i = 0; i < size; i++){
                result++;
                TreeNode* node = que.front();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return result;
    }
};

  • 时间复杂度：O(n)

  • 空间复杂度：O(n)

完全二叉树

在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^(h-1) 个节点。

完全二叉树只有两种情况，情况一：就是满二叉树，情况二：最后一层叶子节点没有满。

对于情况一，可以直接用 2^树深度 - 1 来计算，注意这里根节点深度为1。

对于情况二，分别递归左孩子，和右孩子，递归到某一深度一定会有左孩子或者右孩子为满二叉树，然后依然可以按照情况1来计算。

完全二叉树（一）如图：

完全二叉树（二）如图：

可以看出如果整个树不是满二叉树，就递归其左右孩子，直到遇到满二叉树为止，用公式计算这个子树（满二叉树）的节点数量。

这里关键在于如何去判断一个左子树或者右子树是不是满二叉树呢？

在完全二叉树中，如果递归向左遍历的深度等于递归向右遍历的深度，那说明就是满二叉树。如图：

在完全二叉树中，如果递归向左遍历的深度不等于递归向右遍历的深度，则说明不是满二叉树，如图：

有人会说：下图这走情况，递归向左遍历的深度等于递归向右遍历的深度，但也不是满二叉树，如题：

但是，上图这棵树，根本不满足对完全二叉树的定义，它不是一个完全二叉树。

那么本题的思路就很明确了，从根节点一直往左、右侧去递归，计算它左右侧深度，如果两侧深度相同的话，说明它的子树是一个满二叉树，满二叉树的节点个数为2^depth - 1，再将节点个数返回给父节点即可。如果两侧深度不相同的话，就继续往下遍历，直到找到满二叉树为止（一定能找到满二叉树，因为一个叶子节点就是一个满二叉树）。

这种方法和上面所说的使用普通二叉树的思路的优势在于，它并不需要去遍历所有的节点，只需一直向左遍历左节点的左孩子的左孩子....以及遍历右节点的右孩子的右孩子...如果存在满二叉树的depth>2的话它将不会遍历全部节点，这样就减少了时间复杂度。

递归三部曲：

  1. 确定递归函数的参数和返回值

参数就是传入树的根节点，返回就返回以该节点为根节点二叉树的节点数量，所以返回值为int类型。

int getNum(TreeNode* node)

  1. 确定终止条件

本题的终止条件除了node为空返回0外，还有当某个节点的子树是满二叉树时返回其节点数量给该节点

if(node == NULL) return 0;
TreeNode* left = node->left;
TreeNode* right = node->right;
int leftDepth = 0, rightDepth = 0;
while(left){
    left = left->left;
    leftDepth++;
}
while(right){
    right = right->right;
    rightDepth++;
}
if(leftDepth == rightDepth)
    return (2 << leftDepth) - 1;

  1. 确定单层递归的逻辑

先求它的左子树的节点数量，再求右子树的节点数量，最后取总和再加一 （加1是因为算上当前中间节点）就是目前节点为根节点的节点数量。

int leftTreeNum = countNodes(root->left);       // 左
int rightTreeNum = countNodes(root->right);     // 右
int result = leftTreeNum + rightTreeNum + 1;    // 中
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;
    }
};

  • 时间复杂度：O(log n × log n)

  • 空间复杂度：O(log n)

clementines_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
leetcode 104. 二叉树的最大深度（C++）
12-22
python版——>leetcode 104：二叉树的最大深度(python) 文章目录题目层次遍历法递归法 题目 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有...
hackerchenzhuo#ccf_pat_leetcode.etc#leetcode 111. 二叉树的最小深度1
07-25
原创：leetcode 111. 二叉树的最小深度记住：最小深度和最大深度方法不同。* Definition for a binary tree node.in
LC-104.二叉树的最大深度
Qiang的博客
04-14 418
LC-104.二叉树的最大深度 这道题是一道简单题，可以使用递归法和迭代法进行求解。 迭代法 迭代法最好就使用队列进行层序遍历，这样每遍历一层，深度+1： class Solution: def maxDepth(self, root: Optional[TreeNode]) -> int: if not root: return 0 depth = 0 from collections import deque
【代码随想录算法训练Day16】LeetCode 104.二叉树的最大深度、LeetCode 111. 二叉树的最小深度、LeetCode 222. 完全二叉树的节点个数
qq_46121420的博客
05-24 270
二叉树第三天
代码随想录算法训练营第12天|LeetCode 226.翻转二叉树、LeetCode 101. 对称二叉树、LeetCode 104.二叉树的最大深度、LeetCode 111.二叉树的最小深度
summersnowzgq的博客
06-23 855
不能使用递归的中序遍历来解决，可以使用递归的前后序遍历或层序遍历来解决。
LeetCode104. 二叉树的最大深度(递归&非递归)
weixin_42307601的博客
05-21 500
LeetCode104.二叉树的最大深度(递归与非递归解法)
代码随想录-Day16 | LeetCode104. 二叉树的最大深度、LeetCode111. 二叉树的最小深度、LeetCode222.完全二叉树的节点个数
最新发布
weixin_45923460的博客
07-24 218
题目链接：104. 二叉树的最大深度题目描述：二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。思路：第一想法就是利用之前层序遍历的解法，计算二叉树的层数就是最大深度。递归法后续再弄。 LeetCode111. 二叉树的最小深度 题目链接：111. 二叉树的最小深度题目描述：给定一个二叉树，找出其最小深度（从根节点到最近叶子节点的最短路径上的节点数量）。思路：还是利用层序遍历，循环里面多加一个条件，当碰到某个节点没有左右孩子，直接提前终止程序。 LeetCode222.完全二叉树的节点个数
算法学习|Day16-二叉树|Leetcode104.二叉树的最大深度，Leetcode111.二叉树的最小深度，Leetcode222.完全二叉树的节点个数
WR_mmc的博客
01-15 905
leetcode一刷，day16-二叉树，春招加油！
代码随想录Day016 | Leetcode 104.二叉树的最大深度 、Leetcode 111.二叉树的最小深度、Leetcode 222.完全二叉树的节点个数
hehechui的博客
01-13 396
【代码】代码随想录Day02 | Leetcode 104.二叉树的最大深度 、Leetcode 111.二叉树的最小深度、Leetcode 222.完全二叉树的节点个数。
LeetCode Java刷题笔记—104. 二叉树的最大深度
终生学习践行者
02-09 609
LeetCode Java刷题笔记—104. 二叉树的最大深度
Day19_二叉树：Leetcode104.二叉树的最大深度 + 559.n叉树的最大深度 + 111.二叉树的最小深度 + 222.完全二叉树的节点个数
qq_43506087的博客
05-15 264
lrmaxlr1。
代码随想录算法训练营第14天 |LeetCode226.翻转二叉树 LeetCode101. 对称二叉树 LeetCode104.二叉树的最大深度 LeetCode111.二叉树的最小深度
2301_79647020的博客
07-16 981
今天的内容应用了好多二叉树遍历的做法，个人对递归更熟悉，主要用递归实现，其实栈和层序遍历也可实现。
java-leetcode题解之第104题二叉树的最大深度.zip
06-18
"java-leetcode题解之第104题二叉树的最大深度.zip" 这个标题提到了两个关键元素：Java 和 LeetCode。LeetCode 是一个在线平台，提供各种编程挑战，帮助开发者提升技能，尤其是算法和数据结构方面。题目编号104是指...
php-leetcode题解之二叉树的最大深度.zip
06-08
在本压缩包“php-leetcode题解之二叉树的最大深度.zip”中，主要涵盖了使用PHP语言解决LeetCode上的一个经典算法问题——“二叉树的最大深度”。LeetCode是一个在线平台，提供了各种编程挑战，旨在提升程序员的技能...
力扣 102题 二叉树的层次遍历 记录
m0_49800270的博客
07-22 646
队列是一种先进先出（FIFO）的数据结构，非常适合于层序遍历，因为我们总是希望按照从树的上层到下层的顺序处理节点。队列操作：使用一个队列来管理待处理的树节点。队列的先进先出特性保证了树的每一层都按照从左到右的顺序被处理。
【LeetCode】分隔链表
qq_26521261的博客
07-20 428
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
Java | Leetcode Java题解之第273题整数转换英文表示
m0_57195758的博客
07-22 305
Java | Leetcode Java题解之第273题整数转换英文表示
LeetCode 188题： 买卖股票的最佳时机IV优化（原创）
it_fly的专栏
07-21 283
算法思路：1.买了j次的最大获利值等于：昨天买了j次，和昨天卖了j-1次，今天再买的最大值；2.卖了j次的最大获利值等于：昨天卖了j次，和昨天买了j次，今天再卖掉的最大值
C++二叉树详解：LeetCode刷题全攻略
"C/C++二叉树宝典（来源于carl）"是一份全面深入的教程，专注于二叉树在C++编程语言中的应用，特别是与LeetCode等在线编程平台上的算法题目的关联。这份资源涵盖了二叉树的基本概念、数据结构、遍历方法（如前序、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值