104.二叉树的最大深度
思路:递归法:后序遍历,先确定递归函数的参数和返回类型,然后找到递归函数的终止条件,在确定单层递归的逻辑,左右中。注意深度和高度的关系。后序遍历的最大高度即为二叉树的最大深度。
class Solution {
public:
int getheight(TreeNode* root)
{
if(root==NULL)
{
return 0;
}
int leftheight = getheight(root->left);
int rightheight = getheight(root->right);
int result = 1+max(leftheight,rightheight);
return result;
}
int maxDepth(TreeNode* root) {
//递归的思想 后序遍历 高度及深度
return getheight(root);
}
};
迭代法:利用层序遍历,每遍历一层,深度++,当队列清空时输出深度。
class Solution {
public:
int maxDepth(TreeNode* root) {
int depth=0;
queue<TreeNode*> que;
if(root!=NULL)
{
que.push(root);
}
while(!que.empty())
{
depth++;
int size =que.size();
while(size--)
{
TreeNode* node = que.front();
que.pop();
if(node->left)
{
que.push(node->left);
}
if(node->right)
{
que.push(node->right);
}
}
}
return depth;
}
};
559.n叉树的最大深度
思路:原理同二叉树,只不过在判断深度的时候要把n个子节点全部判断。
递归法:
class Solution {
public:
int maxDepth(Node* root) {
//后序遍历 递归
if(root==NULL)
{
return 0;
}
int depth=0;
for(int i =0;i<root->children.size();i++)
{
depth = max(depth,maxDepth(root->children[i]));
}
return depth+1;
}
};
111.二叉树的最小深度
思路:要注意叶子节点的概念,叶子节点是指没有子节点的节点。
递归法:后序遍历,先确定递归函数的参数和返回类型,在确定递归的终止条件,再确定单层递归的逻辑。左右中。如果子节点一边为空另一边不为空,当前最小深度为1+不为空的节点深度,如果两边都为空,当前深度为1,如果两边都不为空,当前最小深度为1+更小的节点深度。
class Solution {
public:
int minDepth(TreeNode* root) {
if(root==NULL)
{
return 0;
}
int leftheight = minDepth(root->left);
int rightheight = minDepth(root->right);
if(root->left==NULL&&root->right!=NULL)
{
return 1+rightheight;
}
else if(root->left!=NULL&&root->right==NULL)
{
return 1+leftheight;
}
int result = 1+min(leftheight,rightheight);
return result;
}
};
迭代法:层序遍历,按层挨个节点遍历,逐层深度++,当遇见节点的左右子节点都为空时,返回深度值。(这里没弄明白为什么while后还要return,不是在while内就可以return出来了吗。)
class Solution {
public:
int minDepth(TreeNode* root) {
queue<TreeNode*> que;
int depth = 0;
if(root!=NULL)
{
que.push(root);
}
else
{
return depth;
}
while(!que.empty())
{
depth++;
int size = que.size();
while(size--)
{
TreeNode* node = que.front();
que.pop();
if(node->left)
{
que.push(node->left);
}
if(node->right)
{
que.push(node->right);
}
if(node->left==NULL&&node->right==NULL)
{
return depth;
}
}
}
return depth;
}
};
222.完全二叉树的节点个数
思路:递归法,先判断递归函数的参数和返回类型,再判断递归的终止条件,再判断单层递归的逻辑。这里可以直接用后序遍历。当前节点数量为子节点数量和+1。
class Solution {
public:
int countNodes(TreeNode* root) {
//后序遍历 递归
if(root==NULL)
{
return 0;
}
int leftnum = countNodes(root->left);
int rightnum = countNodes(root->right);
int result = leftnum+rightnum+1;
return result;
}
};
根据完全二叉树的特性,可以简化遍历,少遍历一些节点,即如果子树是一个满二叉树,只需要得到它的深度,通过2^深度-1就可以计算出子树的节点个数。但此时递归函数的终止条件需要额外加上,判断子树的左右深度是否相同,相同时返回节点个数。
class Solution {
public:
int countNodes(TreeNode* root) {
// 利用完全二叉树性质 递归
if(root== NULL)
{
return 0;
}
int leftdepth=0;
int rightdepth=0;
TreeNode* leftnode = root->left;
TreeNode* rightnode = root->right;
while(leftnode)
{
leftnode=leftnode->left;
leftdepth++;
}
while(rightnode)
{
rightnode=rightnode->right;
rightdepth++;
}
if(leftdepth==rightdepth)
{
return (2<<leftdepth)-1;
}
int leftnum = countNodes(root->left);
int rightnum =countNodes(root->right);
int result = leftnum+rightnum+1;
return result;
}
};
收获:
1、熟练使用递归法后序遍历,要先判断递归函数的参数和返回类型,确定递归函数的终止条件,确定单层递归的逻辑。