312 lines
9.7 KiB
Markdown
312 lines
9.7 KiB
Markdown
<p align="center">
|
||
<a href="https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ"><img src="https://img.shields.io/badge/知识星球-代码随想录-blue" alt=""></a>
|
||
<a href="https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw"><img src="https://img.shields.io/badge/刷题-微信群-green" alt=""></a>
|
||
<a href="https://img-blog.csdnimg.cn/20201210231711160.png"><img src="https://img.shields.io/badge/公众号-代码随想录-brightgreen" alt=""></a>
|
||
<a href="https://space.bilibili.com/525438321"><img src="https://img.shields.io/badge/B站-代码随想录-orange" alt=""></a>
|
||
</p>
|
||
<p align="center"><strong>欢迎大家参与本项目，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
|
||
|
||
|
||
> 和求最大深度一个套路？
|
||
|
||
## 111.二叉树的最小深度
|
||
|
||
题目地址：https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/
|
||
|
||
给定一个二叉树，找出其最小深度。
|
||
|
||
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
|
||
|
||
说明: 叶子节点是指没有子节点的节点。
|
||
|
||
示例:
|
||
|
||
给定二叉树 [3,9,20,null,null,15,7],
|
||
|
||
|
||
|
||
返回它的最小深度 2.
|
||
|
||
## 思路
|
||
|
||
看完了这篇[二叉树：看看这些树的最大深度](https://mp.weixin.qq.com/s/guKwV-gSNbA1CcbvkMtHBg)，再来看看如何求最小深度。
|
||
|
||
直觉上好像和求最大深度差不多，其实还是差不少的。
|
||
|
||
遍历顺序上依然是后序遍历（因为要比较递归返回之后的结果），但在处理中间节点的逻辑上，最大深度很容易理解，最小深度可有一个误区，如图：
|
||
|
||
|
||
|
||
这就重新审题了，题目中说的是：**最小深度是从根节点到最近叶子节点的最短路径上的节点数量。**，注意是**叶子节点**。
|
||
|
||
什么是叶子节点，左右孩子都为空的节点才是叶子节点！
|
||
|
||
## 递归法
|
||
|
||
来来来，一起递归三部曲：
|
||
|
||
1. 确定递归函数的参数和返回值
|
||
|
||
参数为要传入的二叉树根节点，返回的是int类型的深度。
|
||
|
||
代码如下：
|
||
|
||
```
|
||
int getDepth(TreeNode* node)
|
||
```
|
||
|
||
2. 确定终止条件
|
||
|
||
终止条件也是遇到空节点返回0，表示当前节点的高度为0。
|
||
|
||
代码如下：
|
||
|
||
```
|
||
if (node == NULL) return 0;
|
||
```
|
||
|
||
3. 确定单层递归的逻辑
|
||
|
||
这块和求最大深度可就不一样了，一些同学可能会写如下代码：
|
||
```
|
||
int leftDepth = getDepth(node->left);
|
||
int rightDepth = getDepth(node->right);
|
||
int result = 1 + min(leftDepth, rightDepth);
|
||
return result;
|
||
```
|
||
|
||
这个代码就犯了此图中的误区：
|
||
|
||
|
||
|
||
如果这么求的话，没有左孩子的分支会算为最短深度。
|
||
|
||
所以，如果左子树为空，右子树不为空，说明最小深度是 1 + 右子树的深度。
|
||
|
||
反之，右子树为空，左子树不为空，最小深度是 1 + 左子树的深度。 最后如果左右子树都不为空，返回左右子树深度最小值 + 1 。
|
||
|
||
代码如下：
|
||
|
||
```C++
|
||
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;
|
||
```
|
||
|
||
遍历的顺序为后序（左右中），可以看出：**求二叉树的最小深度和求二叉树的最大深度的差别主要在于处理左右孩子不为空的逻辑。**
|
||
|
||
整体递归代码如下：
|
||
```C++
|
||
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);
|
||
}
|
||
};
|
||
```
|
||
|
||
精简之后代码如下：
|
||
|
||
```C++
|
||
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));
|
||
}
|
||
};
|
||
```
|
||
|
||
**精简之后的代码根本看不出是哪种遍历方式，所以依然还要强调一波：如果对二叉树的操作还不熟练，尽量不要直接照着精简代码来学。**
|
||
|
||
## 迭代法
|
||
|
||
相对于[二叉树：看看这些树的最大深度](https://mp.weixin.qq.com/s/guKwV-gSNbA1CcbvkMtHBg)，本题还可以使用层序遍历的方式来解决，思路是一样的。
|
||
|
||
如果对层序遍历还不清楚的话，可以看这篇：[二叉树：层序遍历登场！](https://mp.weixin.qq.com/s/Gb3BjakIKGNpup2jYtTzog)
|
||
|
||
**需要注意的是，只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点**
|
||
|
||
代码如下：（详细注释）
|
||
|
||
```C++
|
||
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;
|
||
}
|
||
};
|
||
```
|
||
|
||
|
||
## 其他语言版本
|
||
|
||
|
||
Java：
|
||
|
||
```Java
|
||
class Solution {
|
||
/**
|
||
* 递归法，相比求MaxDepth要复杂点
|
||
* 因为最小深度是从根节点到最近**叶子节点**的最短路径上的节点数量
|
||
*/
|
||
public int minDepth(TreeNode root) {
|
||
if (root == null) {
|
||
return 0;
|
||
}
|
||
int leftDepth = minDepth(root.left);
|
||
int rightDepth = minDepth(root.right);
|
||
if (root.left == null) {
|
||
return rightDepth + 1;
|
||
}
|
||
if (root.right == null) {
|
||
return leftDepth + 1;
|
||
}
|
||
// 左右结点都不为null
|
||
return Math.min(leftDepth, rightDepth) + 1;
|
||
}
|
||
}
|
||
```
|
||
|
||
```Java
|
||
class Solution {
|
||
/**
|
||
* 迭代法，层序遍历
|
||
*/
|
||
public int minDepth(TreeNode root) {
|
||
if (root == null) {
|
||
return 0;
|
||
}
|
||
Deque<TreeNode> deque = new LinkedList<>();
|
||
deque.offer(root);
|
||
int depth = 0;
|
||
while (!deque.isEmpty()) {
|
||
int size = deque.size();
|
||
depth++;
|
||
for (int i = 0; i < size; i++) {
|
||
TreeNode poll = deque.poll();
|
||
if (poll.left == null && poll.right == null) {
|
||
// 是叶子结点，直接返回depth，因为从上往下遍历，所以该值就是最小值
|
||
return depth;
|
||
}
|
||
if (poll.left != null) {
|
||
deque.offer(poll.left);
|
||
}
|
||
if (poll.right != null) {
|
||
deque.offer(poll.right);
|
||
}
|
||
}
|
||
}
|
||
return depth;
|
||
}
|
||
}
|
||
```
|
||
|
||
Python：
|
||
|
||
递归法：
|
||
|
||
```python
|
||
class Solution:
|
||
def minDepth(self, root: TreeNode) -> int:
|
||
if not root:
|
||
return 0
|
||
if not root.left and not root.right:
|
||
return 1
|
||
|
||
min_depth = 10**9
|
||
if root.left:
|
||
min_depth = min(self.minDepth(root.left), min_depth) # 获得左子树的最小高度
|
||
if root.right:
|
||
min_depth = min(self.minDepth(root.right), min_depth) # 获得右子树的最小高度
|
||
return min_depth + 1
|
||
```
|
||
|
||
迭代法：
|
||
|
||
```python
|
||
class Solution:
|
||
def minDepth(self, root: TreeNode) -> int:
|
||
if not root:
|
||
return 0
|
||
que = deque()
|
||
que.append(root)
|
||
res = 1
|
||
|
||
while que:
|
||
for _ in range(len(que)):
|
||
node = que.popleft()
|
||
# 当左右孩子都为空的时候，说明是最低点的一层了，退出
|
||
if not node.left and not node.right:
|
||
return res
|
||
if node.left is not None:
|
||
que.append(node.left)
|
||
if node.right is not None:
|
||
que.append(node.right)
|
||
res += 1
|
||
return res
|
||
```
|
||
|
||
|
||
Go：
|
||
|
||
|
||
|
||
|
||
-----------------------
|
||
* 作者微信：[程序员Carl](https://mp.weixin.qq.com/s/b66DFkOp8OOxdZC_xLZxfw)
|
||
* B站视频：[代码随想录](https://space.bilibili.com/525438321)
|
||
* 知识星球：[代码随想录](https://mp.weixin.qq.com/s/QVF6upVMSbgvZy8lHZS3CQ)
|
||
<div align="center"><img src=../pics/公众号.png width=450 alt=> </img></div>
|