引言
- 104.二叉树的最大深度
- 559.n叉树的最大深度
- 111.二叉树的最小深度
- 222.完全二叉树的节点个数
1.# 二叉树的最大深度
| Category | Difficulty | Likes | Dislikes |
|---|---|---|---|
| algorithms | Easy (77.14%) | 1542 | - |
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
3
/ \
9 20
/ \
15 7
返回它的最大深度 3 。
1.1.递归法
前序遍历：
class Solution {
public:
int maxDepth(TreeNode* root) {
int depth = 0;
dfs(root, 0, depth);
return depth;
}
private:
// 前序遍历，一层一层的深入，参数使用引用进行深入，不需要返回值，从根节点开始计数
void dfs(TreeNode* node, int cur_depth, int& depth) {
if (nullptr == node) {
depth = std::max(cur_depth, depth);
return;
}
dfs(node->left, cur_depth + 1, depth); // 隐式回归,注意不能使用depth++
dfs(node->right, cur_depth + 1, depth);
}
};
后序遍历：
class Solution {
public:
int maxDepth(TreeNode* root) { return dfs(root); }
private:
// 后序遍历，类似于触底反弹，最底层开始计数
int dfs(TreeNode* node) {
if (nullptr == node) {
return 0;
}
int left_depth = 1 + dfs(node->left);
int right_depth = 1 + dfs(node->right);
return std::max(left_depth, right_depth);
}
};
1.2.迭代法
一共有多少层，就有多深，层序遍历：
class Solution {
public:
int maxDepth(TreeNode* root) {
if (nullptr == root) return 0;
std::queue<TreeNode*> que;
que.push(root);
int depth = 0;
while (!que.empty()) {
depth++;
for (int i = que.size(); i > 0; i--) {
TreeNode* cur = que.front();
que.pop();
if (cur->left) que.push(cur->left);
if (cur->right) que.push(cur->right);
}
}
return depth;
}
};
2.N 叉树的最大深度
| Category | Difficulty | Likes | Dislikes |
|---|---|---|---|
| algorithms | Easy (74.88%) | 333 | - |
给定一个 N 叉树，找到其最大深度。
最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。
N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。
示例 1：
image.png
输入：root = [1,null,3,2,4,null,5,6]
输出：3
示例 2：
image.png
输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：5
提示：
- 树的深度不会超过
1000。 - 树的节点数目位于
[0, 10<sup>4</sup>]之间。
2.1.递归法
class Solution {
public:
int maxDepth(Node* root) {
int depth = 0;
dfs(root, 1, depth);
return depth;
}
private:
// 前序遍历，从根节点开始计数
void dfs(Node* node, int cur_depth, int& depth) {
if (nullptr == node) {
// 特别小心，这次不能写在这里，因为nullptr没有存入vector中，永远不会进入这里
// depth = std::max(cur_depth, depth);
return;
}
depth = std::max(cur_depth, depth);
for (auto child : node->children) {
dfs(child, cur_depth + 1, depth);
}
}
};
因为nullptr没有存入vector中，所以也就不能使用触底反弹的后序遍历进行统计。、
2.2.迭代法
同样使用层序遍历：
class Solution {
public:
int maxDepth(Node* root) {
int depth = 0;
std::queue<Node*> que;
if (root != nullptr) que.push(root);
while (!que.empty()) {
depth++;
for (int i = que.size(); i > 0; i--) {
Node* cur = que.front();
que.pop();
for (auto& child : cur->children) {
que.push(child);
}
}
}
return depth;
}
};
3. 二叉树的最小深度
| Category | Difficulty | Likes | Dislikes |
|---|---|---|---|
| algorithms | Easy (51.72%) | 952 | - |
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。
示例 1：
image.png
输入：root = [3,9,20,null,null,15,7]
输出：2
示例 2：
输入：root = [2,null,3,null,4,null,5,null,6]
输出：5
提示：
- 树中节点数的范围在
[0, 10<sup>5</sup>]内 -1000 <= Node.val <= 1000
3.1.迭代法
前序遍历：
class Solution {
public:
int minDepth(TreeNode* root) {
if (root == nullptr) return 0;
int depth = std::numeric_limits<int>::max();
dfs(root, 1, depth);
return depth;
}
private:
// 前序遍历：根节点开始计数，引用传递参数
void dfs(TreeNode* node, int depth, int& min_depth) {
// 注意终止条件
if (node->left == nullptr && node->right == nullptr) {
min_depth = std::min(depth, min_depth);
return;
}
if (node->left) dfs(node->left, depth + 1, min_depth);
if (node->right) dfs(node->right, depth + 1, min_depth);
}
};
后序遍历：
class Solution {
public:
int minDepth(TreeNode* root) {
if (root == nullptr) return 0;
return dfs(root);
}
private:
// 后序遍历：触底反弹
int dfs(TreeNode* node) {
// 注意终止条件
if (node->left == nullptr && node->right == nullptr) {
return 1;
}
int left_depth = std::numeric_limits<int>::max();
int right_depth = std::numeric_limits<int>::max();
if (node->left) left_depth = 1 + dfs(node->left);
if (node->right) right_depth = 1 + dfs(node->right);
return std::min(left_depth, right_depth);
}
};
3.2.迭代法
依然是层序遍历：
class Solution {
public:
int minDepth(TreeNode* root) {
if (root == nullptr) return 0;
int min_depth = 0;
std::queue<TreeNode*> que;
que.push(root);
while (!que.empty()) {
min_depth++;
for (int i = que.size(); i > 0; i--) {
TreeNode* cur = que.front();
que.pop();
if (cur->left) que.push(cur->left);
if (cur->right) que.push(cur->right);
if (cur->left == nullptr && cur->right == nullptr) {
return min_depth;
}
}
}
return min_depth;
}
};
4. 完全二叉树的节点个数
| Category | Difficulty | Likes | Dislikes |
|---|---|---|---|
| algorithms | Medium (80.75%) | 897 | - |
给你一棵** 完全二叉树** 的根节点 root ，求出该树的节点个数。
完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2<sup>h</sup> 个节点。
示例 1：
image.png
输入：root = [1,2,3,4,5,6]
输出：6
示例 2：
输入：root = []
输出：0
示例 3：
输入：root = [1]
输出：1
提示：
- 树中节点的数目范围是
[0, 5 * 10<sup>4</sup>] 0 <= Node.val <= 5 * 10<sup>4</sup>- 题目数据保证输入的树是 完全二叉树
进阶：遍历树来统计节点是一种时间复杂度为 O(n) 的简单解决方案。你可以设计一个更快的算法吗？
4.1.暴力法
不管用什么遍历方式，遍历一遍进行统计：
class Solution {
public:
int countNodes(TreeNode* root) {
int num = 0;
dfs(root, num);
return num;
}
private:
void dfs(TreeNode* node, int& num) {
if (node == nullptr) return;
num++;
dfs(node->left, num);
dfs(node->right, num);
}
};
4.2.参考思想及代码实现
以左子树和右子树的思想进行解题：
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);
}
};
image.png
class Solution {
public:
int countNodes(TreeNode* root) {
if (root == nullptr) return 0;
TreeNode* left = root->left;
TreeNode* right = root->right;
// 这里初始为0是有目的的，为了下面求指数方便
int leftDepth = 0, rightDepth = 0;
while (left) { // 求左子树深度
left = left->left;
leftDepth++;
}
while (right) { // 求右子树深度
right = right->right;
rightDepth++;
}
// 说明是满二叉树，直接利用性质进行求解
if (leftDepth == rightDepth) {
return (2 << leftDepth) - 1;
}
// 如果不是，则分别递归继续判断
return countNodes(root->left) + countNodes(root->right) + 1;
}
};
