代码随想录算法训练营第十六天|104.二叉树的最大深度、111.二叉树的最小深度、222.完全二叉树的节点个数

文档链接：代码随想录

LeetCode104.二叉树的最大深度

题目链接：https://leetcode.cn/problems/maximum-depth-of-binary-tree/

思路：这道题在练习层次遍历的时候就出现过，用层次遍历完全可以解决。这里提供一种新思路，后序遍历。首先我们要区分一下高度和深度这两个概念，对于一棵二叉树来说，深度是自顶向下的，也就是从当前节点到叶子节点，而高度是自底向上的，也就是从叶子节点到当前节点。区分了这两者之后，二叉树的最大深度就可以看作根节点的高度，求高度我们一般用后序遍历。同样，如果是求深度一般采用前序遍历。

后序遍历：

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

---

LeetCode111.二叉树的最小深度

题目链接：https://leetcode.cn/problems/minimum-depth-of-binary-tree/

思路：

本题依然是前序遍历和后序遍历都可以，前序求的是深度，后序求的是高度。

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

那么使用后序遍历，其实求的是根节点到叶子节点的最小距离，就是求高度的过程，不过这个最小距离 也同样是最小深度。

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

后序遍历：

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

---

LeetCode222.完全二叉树的节点个数

题目链接：https://leetcode.cn/problems/count-complete-tree-nodes/

思路：自己写的时候第一想法层序遍历，又试着递归也写出来了。但是发现跟完全二叉树这个条件无关。

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

完全二叉树只有两种情况，情况一：就是满二叉树，情况二：最后一层叶子节点没有满。

对于情况一，可以直接用 2^树深度 - 1 来计算，注意这里根节点深度为1。

对于情况二，分别递归左孩子，和右孩子，递归到某一深度一定会有左孩子或者右孩子为满二叉树，然后依然可以按照情况1来计算。

完全二叉树的后序遍历：

class Solution {
public:
    int countNodes(TreeNode* root) {
        if(root == NULL) return 0;
        TreeNode* left = root->left;
        TreeNode* right = root->right;
        int leftDepth = 0;
        int rightDepth = 0;
        while(left != NULL) {
            left = left->left;
            leftDepth++;
        }
        while(right != NULL) {
            right = right->right;
            rightDepth++;
        }
        if(leftDepth == rightDepth) return (2 << leftDepth) - 1;
        int leftNodes = countNodes(root->left);
        int rightNodes = countNodes(root->right);
        int sumNodes = leftNodes + rightNodes + 1;
        return sumNodes;
    }
};

普通二叉树的后序遍历：

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

层序遍历：

class Solution {
public:
    int countNodes(TreeNode* root) {
        queue<TreeNode*> que;
        int result = 0;
        if(root != NULL) que.push(root);
        while(!que.empty()) {
            int size = que.size();
            result += size;
            for(int i = 0; i <  size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if(node->left != NULL) que.push(node->left);
                if(node->right != NULL) que.push(node->right);
            }
        }
        return result;
    }
};

总结：越发觉得后序遍历和层序遍历好用，还是补打卡，冲冲冲！