代码随想录DAY16｜104.二叉树的最大深度 559.n叉树的最大深度 111.二叉树的最小深度 222.完全二叉树的节点个数

最新推荐文章于 2024-09-20 10:10:11 发布
最新推荐文章于 2024-09-20 10:10:11 发布
阅读量42 收藏
点赞数
文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dorothy603/article/details/131146626
版权

104.二叉树的最大深度

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
Input: root = [3,9,20,null,null,15,7]
Output: 3

  1. 什么是二叉树节点的深度？
    指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）
  2. 什么是二叉树节点的高度？
    指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始）
  3. 怎么求深度？
    前序遍历（中左右）
  4. 怎么求高度？
    后序遍历（左右中）

本题根节点的高度就是二叉树的最大深度，因而用后序遍历来计算树的高度。

方法一：递归法，后序遍历
返回条件：空节点

class Solution {
    public int maxDepth(TreeNode root) {
        // 递归法
        return getHeight(root);
    }
    public int getHeight(TreeNode node) {
        if (node == null) {
            return 0;
        }
        int leftHeight = getHeight(node.left);
        int rightHeight = getHeight(node.right);
        int height = Math.max(leftHeight, rightHeight) + 1;
        return height;
    }
}

简化

class solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == null) return 0;
        return 1 + max(maxDepth(root->left), maxDepth(root->right));
    }
};

方法二：递归法，前序遍历

class Solution {
    int result = 0;
    public int maxDepth(TreeNode root) {
        // 递归法（回溯，直接求深度）
        if (root == null) return result;
        getDepth(root, 1);
        return result;
    }
    public void getDepth(TreeNode node, int depth) {
        // 前序遍历
        if (node.left == null && node.right == null) {
            result = Math.max(result, depth);
        }
        if (node.left != null) {
            getDepth(node.left, depth+1);
        }
        if (node.right != null) {
            getDepth(node.right, depth+1);
        }
    }
}

返回条件：叶子节点，前序遍历

class Solution {
    int result = 0;
    public int maxDepth(TreeNode root) {
        if (root == null) return result;
        getDepth(root, 0);
        return result;
    }
    public void getDepth(TreeNode node, int depth) {
        depth++;
        result = result > depth ? result:depth;
        if (node.left == null && node.right == null) {// leaf node
            return;
        }
        if (node.left != null) getDepth(node.left, depth); 
        if (node.right != null) getDepth(node.right, depth);
    }
}

有回溯，前序

class Solution {
    int result = 0;
    public int maxDepth(TreeNode root) {
        // 递归法（回溯，直接求深度）
        if (root == null) return result;
        getDepth(root, 1);
        return result;
    }
    public void getDepth(TreeNode node, int depth) {
        result = result > depth ? result:depth; // 中
        if (node.left == null && node.right == null) {// leaf node
            return;
        }
        if (node.left != null){ //左
            depth++;
            getDepth(node.left, depth);
            depth--; //回溯
        } 
        if (node.right != null) { //右
            depth++;
            getDepth(node.right, depth);
            depth--; //回溯
        }
    }
}

方法三：迭代法，层序遍历

class Solution {
    public int maxDepth(TreeNode root) {
        // 层序遍历
        Deque<TreeNode> queue = new LinkedList<>();
        int depth = 0;
        if (root == null) return 0;
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            depth++; //注意depth增加的位置
            while (size -- > 0) {
                TreeNode node = queue.poll();
                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
            }
        }
        return depth;
    }
}

二叉树的最小深度

给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

思路：

  1. 前序后序遍历都可以，前序求深度，后序求高度
  2. 求最小深度，求根节点到叶子节点（左右孩子都为空）的最小距离，即求最小高度，对根节点进行后序遍历
  3. 注意：最小深度是到叶子节点的距离，
  4. 求二叉树的最小深度和求二叉树的最大深度的差别主要在于处理左右孩子不为空的逻辑。

递归三步曲：
第一步，确定递归函数的参数和返回值：int getHeight(TreeNode node)
第二步，确定终止条件：遇到空节点
第三步，确定单层递归的逻辑：注意下图的错误
左子树空，右子树+1
右子树空，左子树+1
左右都不空，左右最小+1
在这里插入图片描述

方法一：递归法

返回条件：空节点

class Solution {
    // 递归法，前序遍历
    public int minDepth(TreeNode root) {
        return getHeight(root);
    }
    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.right == null && node.left != null) {
            return 1 + leftHeight;
        }
        return 1 + Math.min(leftHeight, rightHeight);
    }
}

返回条件：叶子节点

class Solution {
    public int minDepth(TreeNode root) {
        if (root == null) return 0;
        return getHeight(root);
    }
    public int getHeight(TreeNode node) {
        if (node.left == null && node.right == null) {
            return 1;
        }
        if (node.left == null && node.right != null) 
        {// 此时，left为空，即使最小但也不是叶子节点，不符合条件
            return 1 + getHeight(node.right);
        }
        if (node.right == null && node.left != null){
            return 1 + getHeight(node.left);
        }
        return 1 + Math.min(getHeight(node.left), getHeight(node.right));
    }
}

简化

class Solution {
    public int minDepth(TreeNode root) {
        // recurssion
        // step2
        if (root == null) {
            return 0;
        }
        // step3
        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 + Math.min(minDepth(root.left), minDepth(root.right));
    }
}

方法二：递归法，前序遍历

class Solution {
    int result = Integer.MAX_VALUE;
    public int minDepth(TreeNode root) {
        if (root == null) return 0;
        getDepth(root, 1);
        return result;
    }
    public void getDepth(TreeNode node, int depth) {
        if (node.left == null && node.right == null) {
            result = Math.min(result, depth);
            return;
        } //中
        if (node.left != null) {
            getDepth(node.left, depth+1);
        } //左
        if (node.right != null) {
            getDepth(node.right, depth+1);
        } //右
    }
}

方法三：层序遍历

class Solution {
    public int minDepth(TreeNode root) {
        // iterative
        Deque<TreeNode> queue = new LinkedList<>();
        if (root == null) {
            return 0;
        }
        queue.offer(root);
        int depth = 0;
        while (!queue.isEmpty()) {
            int size = queue.size(); // will change accoring to offer, so add first
            depth++;
            while (size -- > 0) { // for one layer
                TreeNode node = queue.poll();
                if (node.left == null && node.right == null) { // already leaf node
                    return depth;
                }
                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
            }
        } 
        return depth;       
    }
}

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

普通二叉树
方法一：递归，后序遍历

class Solution {
    public int countNodes(TreeNode root) {
        // recursive O(n)
        if (root == null) return 0;
        return countNodes(root.left) + countNodes(root.right) + 1;
    }
}

方法二：迭代，层序遍历

class Solution {
    public int countNodes(TreeNode root) {
        // iterative
        Deque<TreeNode> queue = new LinkedList<>();
        if (root == null) return 0;
        queue.offer(root);
        int count = 0;
        while (!queue.isEmpty()) {
            int size = queue.size();
            while (size -- > 0) {
                TreeNode node = queue.poll();
                count++;
                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
            }
        }
        return count;
    }
}

时间复杂度：O(n)
空间复杂度：O(n)

完全二叉树
思路：

完全二叉树的特证？

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

完全二叉树的两种可能？

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

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

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

怎么判断是不是满二叉树？

如果递归向左遍历的深度等于递归向右遍历的深度，就是满二叉树。

class Solution {
    public int countNodes(TreeNode root) {
        // step2: 终止条件，满二叉树，用公式计算节点个数
        // 开始根据左深度和右深度是否相同来判断该子树是不是满二叉树
        if (root == null) return 0;
        TreeNode leftNode = root.left;
        TreeNode rightNode = root.right;
        int leftDepth = 0; // initialize as 0 for exponential
        int rightDepth = 0;
        while (leftNode != null) {
            leftNode = leftNode.left;
            leftDepth++;
        }
        while (rightNode != null) {
            rightNode = rightNode.right;
            rightDepth++;
        }
        if (leftDepth == rightDepth) { // left == right depth, full binary tree
            return (2 << leftDepth) - 1; 
        }
        // step3: 单层递归的逻辑
        // left right middle 后序遍历
        return countNodes(root.left) + countNodes(root.right) + 1; //左右中
    }
}

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

补：n叉树的最大深度
题目链接：https://leetcode.com/problems/maximum-depth-of-n-ary-tree/

EssieDing
关注
leetcode 104. 二叉树的最大深度（C++）
12-22
python版——>leetcode 104：二叉树的最大深度(python) 文章目录题目层次遍历法递归法 题目 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有...
c语言编程题之树操作二叉树的最大深度.zip
04-02
本主题聚焦于如何计算二叉树的最大深度，这是一个经典的问题，通常在算法竞赛或面试中出现。 首先，我们需要理解什么是树的深度。在一棵二叉树中，根节点的深度为0。如果一个节点有非空子节点，那么这个节点的深度...
解决二叉树最大深度问题的完整Java代码
07-20
### 解决二叉树最大深度问题的完整Java代码解析 #### 一、二叉树最大深度的概念 在数据结构中，二叉树是一种常见的非线性数据结构，它由节点组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树...
johanazhu#leetcode#【Day 13 】2021-05-22 - 104. 二叉树的最大深度1
07-25
题目地址：思路这个题简单，使用二叉树，先循环左边的，再循环右边的，递归思想代码* Definition for a binary tree node.* fun
力扣 16.最接近的三数之和
qq_51352130的博客
09-16 352
设 s=nums[i]+nums[j]+nums[k]，为了判断 s 是不是与 target 最近的数，我们还需要用一个变量 minDiff 维护 ∣s−target∣ 的最小值。分类讨论：如果 s=target，那么答案就是 s，直接返回 s。如果 s>target，那么如果 s−target<minDiff，说明找到了一个与 target 更近的数，更新 minDiff 为 s−target，更新答案为 s。然后和三数之和一样，把 k 减一。
代码随想录算法训练营Day7
lynyzy的博客
09-18 443
双指针
拥塞控制算法为何失效，网络为何难以测量？
Netfilter
09-14 7272
所以你知道实验室仿真的宇宙第一算法为啥拉了吧，也就不用再问为什么部署了 bbr 却还不如 cubic 了吧，如果你还希望研发一个精准的，普适的端到端算法，我劝你改行去卖皮鞋，至少还有很多经理市场。这和上一篇说的测量系统容量的方法并不矛盾，因为对于网络传输系统而言，系统是动态变化的，在流量部署到系统上并开始传输时，没有全局视图，就不能指望全局公平，留下的 gap 是固有的，没法靠算法弥补。，超级经典的一篇论文，我推荐过不止一次，因此我本文不谈异构问题，说点别的，比如拓扑。对，就是要砸，因为我不干了。
【例题】lanqiao4425 咖啡馆订单系统
m0_73676887的博客
09-17 282
样例输入样例输出3 2样例说明输入的数组为：【3，1，2】增量序列为：【2，1】当增量 h=2：对于每一个索引 i，我们会将数组元素 arr[i] 与 arr[i−h] 进行比较，并进行可能的交换。当增量 h=1：这就是一个普通的插入排序。总结：总共进行了 3 次比较，2 次交换。
双指针算法专题（2）
我要学编程的博客
09-16 950
LeetCode刷题：有效三角形的个数、查找总价格为目标值的两个商品（两数之和）、三数之和、四数之和
二分系列(二分答案最大值)9/15.16
2301_78191305的博客
09-16 983
给你一批机器，及其它制作一块合金所需要的不同种类金属的个数。第一台机器制作一块合金，需要一块A金属、一块B金属、一块C金属。我们对每一类机器所需要的各种种类的金属进行判断，如果仓库里面有，就不需要花钱；如果mid-index<1的，要计算有多少个1。前n项和:(mid-1+1)*(mid-1)/2+leftCount-(mid-1);根据贪心:以index为中心，向两边依次-1，直到减到1为止。如果mid-rightCount<1,先计算多少个1，xxx。
Python 实现 LM 算法（Levenberg-Marquardt）
qq_42568323的博客
09-15 1457
Levenberg-Marquardt（LM）算法是求解非线性最小二乘问题的著名方法。它结合了高斯牛顿法和梯度下降法的优点，广泛用于非线性曲线拟合、机器学习、最优参数估计等领域。LM 算法的一个主要特点是能够在问题接近线性时，像高斯牛顿法一样快速收敛；而在问题严重非线性时，它通过梯度下降法的机制避免了求解发散。它是一个调和局部曲率信息与梯度信息的混合算法。在本篇博客中，我们详细介绍了 Levenberg-Marquardt 算法的基本思想、数学原理以及其 Python 的面向对象实现。
LeetCode2414题： 最长的字母序连续子字符串的长度（原创）
最新发布
it_fly的专栏
09-20 423
此题算法实现思路：从头到尾不断比较字符串中相邻得两个字符，如果后一个字符比前一个字符大1，那么当前子字符串就是连续的，将其长度加1，如果不是,那么当前连续子字符串就到此为止，重新开始计算新的子字符串
xtu oj 折纸
m0_75005390的博客
09-16 438
第一行是一个整数�(1≤�≤10000),表示样例的个数。以后每行一个样例，为两个整数1≤�,�≤1000。一个长为�,宽为�矩形的纸，我们沿�边(左边)的中点与右上顶点的边折叠，求左上顶点在折叠以后离下边的距离？每行输出一个样例的结果，如果结果为整数，输出一个整数；否则输出一个分数，并保证分子与分母互质。
leetcode - 分治思想
m0_68402491的博客
09-16 538
这里快排我们统一使用 数组分三块 和 随机产生基准值的方法实现排序。
【JVM】判断对象能否回收的两种方法：引用计数算法，可达性分析算法
Jilit_jilit的博客
09-13 521
判断对象能否回收的两种方法——引用计数算法与可达性分析算法
P1439 【模板】最长公共子序列 （线性DP，LCS + LIS）
2302_79440616的博客
09-17 862
给出12n的两个排列P1​和P2​，求它们的最长公共子序列。
力扣第200题 岛屿数量
buaichifanqie的博客
09-10 693
记录一下刷题历程 力扣第200题 岛屿数量。
GC的算法
ccccco1的博客
09-17 1124
标记-清除（Mark-Sweep）通过标记存活对象并清除未标记对象来进行垃圾回收，适合处理较为复杂的对象引用关系。分代回收（Generational Collection）根据对象生命周期的不同，将堆分为多个代，频繁回收短命对象，减少对长期存活对象的频繁扫描，提升垃圾回收效率。C# 的垃圾回收器通过结合这两种机制，能够在保持良好性能的同时，自动管理内存的分配与回收，极大地简化了开发者的工作。
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被依次加入队列中，然后逐个出队并将其子节点加入队列。 引用中给出了一个实现翻转二叉树的代码示例...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值