Day 16 104.二叉树的最大深度 559.n叉树的最大深度 111.二叉树的最小深度 222.完全二叉树的节点个数

二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例： 给定二叉树 [3,9,20,null,null,15,7]，

返回它的最大深度 3 。

​ 二叉树的深度和高度的定义：

​ 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）

​ 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始）

​ 用人话说就是层数；

​ 如果用前序遍历（中左右）的话，得到的就是二叉树的深度；如果用后序遍历（左右中）的话，得到的则是二叉树的高度；

​ 由于二叉树的最大深度其实就是二叉树的最大高度，所以很多题解给出的方式实际上是最大高度的求解；

/**
 * 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 GetHeight1(TreeNode* node){
        if(node == NULL)    return 0;
        int leftheight = GetHeight1(node->left);//左
        int rightheight = GetHeight1(node->right);//右
        int maxheight = 1 + max(leftheight,rightheight);//中
        return maxheight;
    }
    int GetHeight2(TreeNode* node){//精简版本
        return 1 + max(GetHeight2(node->left),GetHeight2(node->right));
    }
    int maxDepth(TreeNode* root) {
        if(root == NULL)    return 0;
        return GetHeight1(root);
        //return GetHeight2(root);
    }
};

n叉树的最大深度

​ 没啥多说的，直接上代码：

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

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;
    }
};

二叉树的最小深度

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明: 叶子节点是指没有子节点的节点。

示例:

给定二叉树 [3,9,20,null,null,15,7],

返回它的最小深度 2.

​ 什么是叶子节点的定义，左右孩子都为空的节点才是叶子节点；

​ 所以如果当此题依然使用后序遍历获取高度的方式来得到最小深度，那么处理返回值时就需要考虑左右子树是否为空；

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; 
        return 1 + min(RightHeight,LeftHeight);
    }
    int minDepth(TreeNode* root) {
        if(root == NULL)    return 0;
        return GetHeight(root);
    }
};

完全二叉树的节点个数

给出一个完全二叉树，求出该树的节点个数。

示例 1：

• 输入：root = [1,2,3,4,5,6]
• 输出：6

示例 2：

• 输入：root = []
• 输出：0

示例 3：

• 输入：root = [1]
• 输出：1

提示：

• 树中节点的数目范围是[0, 5 * 10^4]
• 0 <= Node.val <= 5 * 10^4
• 题目数据保证输入的树是 完全二叉树

​ 若视为普通二叉树，使用后序遍历得到：

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);
    }
};

​ 显而易见，此段代码和层序遍历一样，也是遍历了所有的节点；

​ 由于题目给出的是完全二叉树，所以可以利用完全二叉树和满二叉树的性质解决；

​ 在完全二叉树中(所有节点必须是“相邻”的)，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置；若最底层为第 h 层，则该层包含 1~ 2^(h-1) 个节点；

​ 所以对于完全二叉树的子树，判断子树是否为满二叉树只需要判断最左侧和最右侧的节点深度是否一致即可得知；

​ 代码实现如下：

/**
 * 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 {
private:
    int getNodesNum(TreeNode* cur) {//递归第一步：确定递归函数的参数和返回值
        if(cur == NULL)	return 0;//递归第二步：确定终止条件：当节点为空时return
        TreeNode* left = cur->left;
        TreeNode* right = cur->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;//由于单个节点处理方式和满二叉树一致，所以此处可视为满二叉树
        }
        //递归第三步：确定单层遍历逻辑
        int leftNum = getNodesNum(cur->left);
        int rightNum = getNodesNum(cur->right);
        return leftNum + rightNum + 1;    
    }
public:
    int countNodes(TreeNode* root) {
        return getNodesNum(root);
    }
};