二叉树深度系列

二叉树的深度：从根节点到该节点的最长简单路径边的条数或者节点数
使用递归法查询二叉树深度：

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

递归三部曲：
1.确定参数与返回值，只要节点信息，返回这棵树的深度
2.确定终止条件，当节点为空的时候，就不再往下递归了
3.确定单层递归的逻辑，先求左子树的深度，再求右子树的深度

使用迭代法获取二叉树深度：
深度与层序遍历是仅仅挂钩的,层序遍历模板总结如下：

int maxDepth(TreeNode* root) {
        if(root==nullptr) return 0;
        queue<TreeNode*> q;
        q.push(root);
        //int depth=0;
        while(!q.empty()) {
            int size=q.size();
            //depth++;
            for(int i=0;i<size;i++) {
                TreeNode* node=q.front();
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
                q.pop();
            }
        }
        //return depth;
    }

例如，n叉树的最大深度；
根据递归法解：

class Solution {
public:
    int maxDepth(Node* root) {
        if(root==nullptr) return 0;
        int max_=0;
        for(auto next:root->children){
            max_=max(max_,maxDepth(next));
        }
        return 1+max_;
    }
};

根据迭代法解：

class Solution {
public:
    int maxDepth(Node* root) {
        if(root==nullptr) return 0;
        queue<Node*> q;
        q.push(root);
        int depth=0;
        while(!q.empty()) {
            int size=q.size();
            depth++;
            for(int i=0;i<size;i++) {
                Node* t=q.front();
                for(auto next:t->children) {
                    q.push(next);
                }
                q.pop();
            }
        }
        return depth;
    }
};

二叉树的最小深度，之前都用前序、中序、后续的递归解法解过了；
现在再用递归法解一下：
1.确定参数与返回值，参数还是节点，返回值就是子树的最小深度
2.确定最终条件，当节点为空时，返回
3.确定单层逻辑，当这个节点为子节点时，那么可以直接返回1，如果这个节点左右子树有不为0时，需要进一步递归不为空的子树，在返回1+min；需要注意的是，限定死了肯定不会递归到空节点，除了根节点，防止min到空节点，导致计数错误。

迭代法解题，很显然，通过层序遍历，当遇到叶子节点的时候一定是最小深度；

class Solution {
public:
    int minDepth(TreeNode* root) {
       if(root==nullptr) return 0;
       queue<TreeNode*> q;
       q.push(root);
       int depth=0;
       while(!q.empty()) {
            int size=q.size();
            depth++;
            for(int i=0;i<size;i++) {
                TreeNode* node=q.front();
                //重点判断逻辑，当这层遇到叶子节点，可以直接返回层数即深度
                if(node->left==nullptr&&node->right==nullptr) {
                    return depth;
                }
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
                q.pop();
            }
       }
       return 0;
    }
};

完全二叉树的节点个数
普通二叉树做法：
1.递归法：

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

2.迭代法，不多写了，还是就相当于遍历一遍
3.根据完全二叉树的特性：
完全二叉树要么左子树和右子树的最大深度相同，这个时候是满二叉树，要么最大深度不同，这个时候不是满的，根据递归寻找下一个满足条件。

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;
        while(left!=nullptr) {
            left=left->left;
            leftDepth++;
        }
        while(right!=nullptr) {
            right=right->right;
            rightDepth++;
        }
        if(leftDepth==rightDepth) {
            return (2<<leftDepth)-1;
        }
        return 1+countNodes(root->left)+countNodes(root->right);
    }
};