【LeetCode】222. 完全二叉树的节点个数（简单）—

【LeetCode】222. 完全二叉树的节点个数（简单）——代码随想录算法训练营Day16

news2024/11/15 15:31:20

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

题目描述

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

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

示例 1：

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

示例 2：

输入：root = []
输出：0

示例 3：

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

提示：

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

进阶：遍历树来统计节点是一种时间复杂度为 O(n) 的简单解决方案。你可以设计一个更快的算法吗？

文章讲解：代码随想录

视频讲解：要理解普通二叉树和完全二叉树的区别！ | LeetCode：222.完全二叉树节点的数量_哔哩哔哩_bilibili

题解1：递归法——针对任意二叉树

思路：使用后续遍历，递归的求出左子树和右子树节点数量，再加1即为整个二叉树的节点数量。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var countNodes = function(root) {
    if (!root) {
        return 0;
    }
    return countNodes(root.left) + countNodes(root.right) + 1;
};

分析：时间复杂度为 O(n)，空间复杂度为 O(logn)。

题解2：二叉树遍历——针对任意二叉树

思路：任意一种二叉树的遍历方式，边遍历边计数。这里使用前序遍历。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var countNodes = function(root) {
    let count = 0;
    const preorder = function (node) {
        if (node) {
            count++;
            preorder(node.left);
            preorder(node.right);
        }
    };
    preorder(root);
    return count;
};

分析：时间复杂度为 O(n)，空间复杂度为 O(logn)。

题解3：——针对完全二叉树

思路：题目中强调了这颗树是一个完全二叉树。根据完全二叉树的特性，对二叉树进行层序遍历，遇到第1个叶子节点或第1个只有左孩子的节点时，即可得出答案。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var countNodes = function(root) {
    let count = 0;
    const queue = [];
    if (root) {
        queue.push(root);
    }
    while (queue.length > 0) {
        let size = queue.length;
        while (size--) {
            const node = queue.shift();
            count++;
            // 如果此节点为第1个叶子节点，二叉树的节点数则为到此节点的数量乘2减1
            if (!node.left) {
                return count * 2 - 1;
            }
            // 如果此节点为第1个没有右孩子的节点，二叉树的节点数则为到此节点的数量乘2
            if (!node.right) {
                return count * 2;
            }
            queue.push(node.left);
            queue.push(node.right);
        }
    }
    return count;
};

分析：时间复杂度为 O(n)，空间复杂度为 O(n)。

题解4：递归+计算——针对完全二叉树

思路：设一个满二叉树的最大深度为 n，则这个满二叉树的节点数为 $2^n - 1$ 。对于一个完全二叉树，一定可以递归的找到为满二叉树的左子树和右子树，根据公式解出答案。

递归分析：

确定递归函数的参数和返回值：参数为当前子树的根节点，返回值为这颗子树的节点数量。
确定递归终止条件：当前节点为空节点时，返回0；当前子树为满二叉树时，返回根据公式求出的结果。
确定单层递归逻辑：返回左子树的节点树加上右子树的节点树再加1，即为当前子树的节点数。

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var countNodes = function(root) {
    if (!root) {
        return 0;
    }
    let leftNum = 0, rightNum = 0;
    let left = root.left, right = root.right;
    // 计算最左节点深度
    while (left) {
        leftNum++;
        left = left.left;
    }
    // 计算最右节点深度
    while (right) {
        rightNum++;
        right = right.right;
    }
    // 最左节点深度等于最右节点深度，说明为满二叉树，计算结果
    if (leftNum === rightNum) {
        return (1 << leftNum + 1) - 1;
    }
    // 不为满二叉树，递归的计算左子树和右子树的节点数之和再加1
    return countNodes(root.left) + countNodes(root.right) + 1;
};

分析：时间复杂度为 O(log²n)，空间复杂度为 O(logn)。