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

104.二叉树的最大深度

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

题目描述：给定一个二叉树 root ，返回其最大深度。

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

递归法（后序遍历）

本题可以使用前序（中左右），也可以使用后序遍历（左右中），使用前序求的就是深度，使用后序求的是高度。

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

这里其实使用的是后序遍历，每次递归计算左右子树的高度，并将最大值传给父节点。

class Solution {
public:
    int maxDepth(TreeNode* root) { return getHeight(root); }

    int getHeight(TreeNode* node) {
        if (node == NULL)
            return 0;
        int leftHeight = getHeight(node->left);
        int rightHeight = getHeight(node->right);
        return 1 + max(leftHeight, rightHeight);
    }
};

迭代法（层序遍历）

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

111.二叉树的最小深度

题目链接：二叉树的最小深度

题目描述：给定一个二叉树，找出其最小深度。

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

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

递归法（后序遍历）

求二叉树的最小深度和求二叉树的最大深度的差别主要在于处理左右孩子不为空的逻辑。

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

迭代法（层序遍历）

广度优先遍历，遇到左右节点都为空的node，直接返回depth

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

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

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

题目描述：给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。

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

递归法（普通二叉树）

class Solution {
public:
    int countNodes(TreeNode* root) { return getNums(root); }

    int getNums(TreeNode* node) {
        if (node == NULL)
            return 0;
        int left = getNums(node->left);
        int right = getNums(node->right);
        return left + right + 1;
    }
};

递归法（完全二叉树）

利用完全二叉树的特性。

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

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

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

class Solution {
public:
    int countNodes(TreeNode* root) { return getNums(root); }

private:
    int getNums(TreeNode* node) {
        if (node == NULL)
            return 0;
        TreeNode* left = node->left;
        TreeNode* right = node->right;
        int leftLen = 0;
        int rightLen = 0;
        while (left) {
            left = left->left;
            leftLen++;
        }
        while (right) {
            right = right->right;
            rightLen++;
        }
        if (leftLen == rightLen) {
            return (2 << leftLen) - 1;
        }
        int leftNum = getNums(node->left);
        int rightNum = getNums(node->right);
        return leftNum + rightNum + 1;
    }
};

迭代法（层序遍历）

层序遍历，记录每层节点的个数，完全不完全二叉树都适用。

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