代码随想录算法训练营第16天,104.二叉树的最大深度、559.N叉树的最大深度、111.二叉树的最小深度、222.完全二叉树的节点数

104.二叉树的最大深度、559.N叉树的最大深度、111.二叉树的最小深度、222.完全二叉树的节点数

104.二叉树的最大深度

递归方式遍历

对于二叉树的最大深度，我们可以用栈递归的方式进行查找，我们定义一个函数，可以返回当前节点最左右子树的最大深度，以此递归。如果当前节点为空节点，我们就返回当前节点值。如果不为空，我们则返回当前节点的最大深度加1.
这样子定义的话，我们初始化深度为零，即使是碰到了空树，我们直接就返回了零。如果仅仅只有根节点，也会向下判断而加1.

代码

class Solution {
public:
    int getmax(TreeNode *p,int k)
    {
        int dep =1;
        if(p==nullptr)
        return k;
        else{
            int left = getmax(p->left,k+1);
            int dep = getmax(p->right,k+1);
            return left>dep? left:dep;
        }
    }
    int maxDepth(TreeNode* root) {
        int k =0;
        int max = getmax(root,k);
        return max;
    }
};

层次遍历

我们知道，层次遍历可以按层访问二叉树，因此，我们可以记录当前访问二叉树的深度，每进入下一层，我们让层数加1；
当访问结束二叉树，我们便可以得知二叉树的深度。

代码

class Solution {
public:
    
    
    int maxDepth(TreeNode* root) {
        if(root==nullptr)
        return 0;
        int k = 0;
        TreeNode * p;
        queue<TreeNode*> que;
        que.push(p);
        int size = 1;
        while(!que.empty())
        {
            k++;
            int next = 0;
            while(size--)
            {
                p = que.front();
                que.pop();
                if(p->left)
                {
                    que.push(p->left);
                    next++;
                }
                if(p->right)
                {
                    que.push(p->right);
                    next++;
                }
            }
            size=next;
        }
        return k;
    }
};

559.N叉树的最大深度

如同上一题一样，可以用层次遍历，层次遍历想法更纯粹一点

本文用递归方式解答。
对于N叉树，当我们访问时，我们可以向父节点返回子树的最大深度加1，而返回时。如果子节点为空，则返回零。

代码

class Solution {
public:
    int maxDepth(Node* root) {
        if(root==nullptr)
        return 0;
        int depth = 0;
        for(int ii = 0;ii<root->children.size();ii++)
            depth = max(depth,maxDepth(root->children[ii]));
        return depth+1;
    }
};

111.二叉树的最小深度

二叉树的最小深度定义：从根节点到最近的叶子节点的距离
因此，我们可以进行遍历。
如果根节点为零，直接返回零
如果根节点没有叶子节点，返回1；
如果一个节点只有一个节点，则返回这个节点的最小深度+1；
据此，我们可以写出代码

代码

class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root==nullptr) return 0;
        if((!root->left)&&(!root->right)) return 1;
        else if(!root->left) return 1+minDepth(root->right);
        else if(!root->right) return 1+minDepth(root->left);
        int mini = min(minDepth(root->left),minDepth(root->right));
        return mini+1;
    }
};

222.完全二叉树的节点数

首先，我们可以将完全二叉树当作是普通二叉树进行处理，不去考虑完全二叉树的性质，只考虑它是一个二叉树。我们用前序遍历的递归算法，遇到非空节点就让节点数+1。再访问它的左右孩子。最后返回节点数即可。

代码

class Solution {
    int num = 0;
public:
    int countNodes(TreeNode* root) {
        if(root==nullptr) return num;
        num++;
        countNodes(root->left);
        countNodes(root->right);
        return num;
    }
};

如果我们将此视为完全二叉树，我们可以进行递归判断。

如果是一个满二叉树，我们就返回2^n-1
如果不是满二叉树，我们就返回左子树的节点数和右子树的节点数+1
如果root等于空节点，我们就返回0
如何判断是不是满二叉树呢
我们分别不断找节点的左孩子和右孩子，如果它的左孩子的深度和右孩子的深度一致，则是满二叉树

class Solution {
    int num = 0;
public:
    int countNodes(TreeNode* root) {
        if(root==nullptr) return 0;
        TreeNode* leftn = root->left;
        TreeNode* rightn = root->right;
        int left_depth = 1;
        int right_depth = 1;
        while(leftn)
        {
            left_depth++;
            leftn=leftn->left;
        }
        while(rightn)
        {
            right_depth++;
            rightn=rightn->right;
        }
        if(right_depth==left_depth)
            return pow(2,left_depth)-1;
        return countNodes(root->left)+countNodes(root->right)+1;
    }
};