day16|LeetCode:● 104.二叉树的最大深度 559.n叉树的最大深度● 111.二叉树的最小深度● 222.完全二叉树的节点个数

题目链接：104. 二叉树的最大深度

递归法后序遍历

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int leftdepth = maxDepth(root->left);
        int rightdepth = maxDepth(root->right);
        return 1 + max(leftdepth, rightdepth);
    }
};

递归三部曲

1.确定返回类型和参数，这里是求最大深度，所以就是int类型，参数为头结点

        if (root == NULL) return 0;

2.确定终止条件：当遍历到叶子结点的下一个结点时，为空时就会返回0（返回类型就是0），也说明那一层的深度为0，其实就是可以确定结果的那一层的逻辑

        if (root == NULL) return 0;

3.确定单层递归的逻辑，先求出左子树的深度，再求出右子树的深度，左右子树深度的最大值加上1就是目前中间结点的深度了。这一步需要与返回类型相配合

一般这个可以代入最后一个结点，中间结点，最后个结点理解，不过这是单层逻辑，只要逻辑上正确就行，直接代入根结点去理解就行了

        int leftdepth = maxDepth(root->left);
        int rightdepth = maxDepth(root->right);
        return 1 + max(leftdepth, rightdepth);

高度和深度，为什么用后序，

高度是叶子结点到根结点的距离，因为从下往上返回结果，所以用后序

深度是根结点到叶子结点的距离，从上往下计数，二刷再来看

也可以使用层序遍历

---

 题目链接：559. N 叉树的最大深度

递归法（也能用层序）

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;
c
    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 len = 0;
        for (int i = 0; i < root->children.size(); i++) {
            len = max(len,maxDepth(root->children[i]));
        }
        return len + 1;
    }
};

递归三部曲

确定返回类型和参数类型：返回类型为int代表深度,参数类型为root

确定终止条件：当遍历到叶子结点的下一个结点时为空返回0

确定单层递归的逻辑，你可以在前中后推测，但是在根节点就可以很好的抽象了，只要求出每个分支的最大值就可以了，最后+1就是中间结点的最大值了，这一步需要与返回类型相配合

其实每一步求法都相同就能用抽象进行了，只要知道第一层就行了

---

题目链接：559. N 叉树的最大深度

递归法

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

递归三部曲

确定返回类型和参数类型：返回类型为int代表树最小深度，参数类型为传入的根节点

确定终止条件：当访问到叶子结点的下一个结点时就返回0，说明那一层的高度为0

终止条件其实就是可以确定结果的那一层的逻辑

确定单层递归的逻辑：一般看根节点：代表两边深度最小的那个+1就是根结点的最小值了，

但是这里还有两种情况：

如果左边根节点为null，只要看右边就行了，反之

理解：

从最后一层自己推测，明白两个逻辑：

前中后序时是代表遍历完哪些分支后输出

只有完成两边的遍历才会结束这个点往上一层遍历

---

题目链接：222. 完全二叉树的节点个数

完全二叉树概念：叶子结点是连续的

因为完全二叉树也是普通二叉树的一种，完全二叉树也适用

普通树递归法

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

递归三部曲

确定返回类型和参数类型:返回类型是int，为结点个数，参数为根节点

确定终止条件：当到达根结点的下一个结点时，因为为空，结点个数为0

确定单层递归逻辑:用根节点为抽象，代表左子树和右子树结点个数自合+本身

明白二叉树两原则就能理解 

提前结束递归法（满二叉树）

逻辑

因为是完全二叉树所以可以用完全二叉树的性质来写结束条件来提前结束递归

性质：除了最后一层其它层必须是满二叉树，所以连上最后一层，要么是满二叉树，要么是单结点，而满二叉树的结点个数我们是知道的，所以我们可以不用遍历到最后一层，直接判断这个结点是满二叉树吗，

所以终止条件为，不是满二叉树就会遍历到根结点返回0，是满二叉树就可以算出来节点数量返回，其它都一样

代码

class Solution {
public:
    int countNodes(TreeNode* root) {
        if (root==nullptr) return 0;
       int lenz = 0;
       int leny = 0;
       TreeNode* a = root->left;
       TreeNode* b = root->right;
       while (a) {
           lenz++;
          a = a->left;
       }
       while (b) {    
           leny++;
          b = b->right;
       }
       if(lenz == leny) return (2<<lenz) - 1;
                                                                      
       int leftlen = countNodes(root->left);
       int rightlen = countNodes(root->right);
       return leftlen + rightlen +1;
    }
};

递归三部曲

就是终止条件的不同，是满二叉树提前结束递归