leetcode 104.二叉树的最大深度
二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）
二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数后者节点数（取决于高度从0开始还是从1开始）
而根节点的高度就是二叉树的最大深度。在二叉树中求高度使用的是后序遍历，因为求高度是从下往上去计数，后序（左右中）的处理逻辑放在最后一步，我们可以把叶子节点的高度返回给其父节点，那么父节点就知道其孩子的高度，其本身的高度只需做一个+1的操作即可，所以要使用后序遍历。求深度使用的是前序遍历（中左右），将处理逻辑放在第一步，二叉树往下遍历一次深度就+1，所以使用前序遍历。
递归法
本题使用后序遍历或前序遍历均可完成。
递归三部曲：
确定递归函数的参数和返回值
参数就是传入树的根节点，返回就返回这棵树的深度，所以返回值为int类型。
int getHeight(TreeNode* node)确定终止条件
遍历的节点遇到空节点就返回0，表示此时高度为0。
if(node == NULL) return 0;确定单层递归的逻辑
先求它的左子树的高度，再求右子树的高度，最后取左右高度最大的数值再+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开始）
那么使用后序遍历，其实求的是根节点到叶子节点的最小距离，就是求高度的过程，不过这个最小距离 也同样是最小深度。
本题还有一个误区，在处理节点的过程中，最大深度很容易理解，最小深度就不那么好理解，如图：
这就重新审题了，题目中说的是：最小深度是从根节点到最近叶子节点的最短路径上的节点数量。注意是叶子节点。
什么是叶子节点，左右孩子都为空的节点才是叶子节点！
递归法
递归三部曲：
确定递归函数的参数和返回值
参数为要传入的二叉树根节点，返回的是int类型的深度。
int getHeight(TreeNode* node)确定终止条件
终止条件也是遇到空节点返回0，表示当前节点的高度为0。
if(node == NULL) return 0;确定单层递归的逻辑
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.完全二叉树的节点个数
可以使用普通二叉树的求法以及利用完全二叉树性质的求法。
普通二叉树
递归法
这道题目的递归法和求二叉树的深度写法类似， 而迭代法（层序遍历）遍历模板稍稍修改一下，记录遍历的节点数量就可以了。
递归遍历的顺序依然是后序（左右中）。
递归三部曲：
确定递归函数的参数和返回值
参数就是传入树的根节点，返回就返回以该节点为根节点二叉树的节点数量，所以返回值为int类型。
int getNum(TreeNode* node)确定终止条件
如果为空节点的话，就返回0，表示节点数为0。
if(node == NULL) return 0;确定单层递归的逻辑
先求它的左子树的节点数量，再求右子树的节点数量，最后取总和再加一 （加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的话它将不会遍历全部节点，这样就减少了时间复杂度。
递归三部曲：
确定递归函数的参数和返回值
参数就是传入树的根节点，返回就返回以该节点为根节点二叉树的节点数量，所以返回值为int类型。
int getNum(TreeNode* node)确定终止条件
本题的终止条件除了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是因为算上当前中间节点）就是目前节点为根节点的节点数量。
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)
扫一扫
4928
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
