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

文章目录

• • • [222. 完全二叉树的节点个数](https://leetcode.cn/problems/count-complete-tree-nodes/)
    • • 一、题目
      • 二、题解
      • • 方法一：递归遍历所有结点
        • 方法二：根据完全二叉树的特性递归
        • 方法三：迭代

---

一、题目

给你一棵 完全二叉树 的根节点 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) 的简单解决方案。你可以设计一个更快的算法吗？

二、题解

方法一：递归遍历所有结点

算法思路

1. 首先，判断根节点是否为空，如果为空，则直接返回节点个数为 0。
2. 统计当前节点的左子树和右子树的节点数：
   • 通过递归调用 countNodes 函数，分别计算当前节点的左子树和右子树的节点个数。这里会涉及到递归的调用，将逐层深入到树的叶子节点，然后逐层返回结果。
3. 计算当前节点及其子树的节点个数：
   • 通过左子树节点数和右子树节点数，加上当前节点自身，得到当前节点及其子树的节点个数。
4. 返回节点个数：
   • 最后，返回当前节点及其子树的节点个数。

具体实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int countNodes(TreeNode* root) {
        int count = 0;
        if(root == nullptr) return 0;
        if(root->left) count++;
        if(root->right) count++;
        int left_count = countNodes(root->left);
        int right_count = countNodes(root->right);
        count = left_count + right_count + 1;
        if(root->left == nullptr && root->right == nullptr){
            return count;
        }
        return count;
    }
};

算法分析

时间复杂度分析：在最坏情况下，每个节点都需要被访问一次，所以时间复杂度为 O(n)，其中 n 是二叉树的节点个数。

空间复杂度分析：在递归过程中，除了栈空间用于函数调用，我们没有使用额外的空间，所以空间复杂度为 O(h)，其中 h 是二叉树的高度。在最坏情况下，二叉树可能退化成链表，高度为 n，所以最坏情况下的空间复杂度为 O(n)。

方法二：根据完全二叉树的特性递归

算法思路

对于完全二叉树，除了最底层可能没有填满外，其余每层的节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。所以，我们可以利用完全二叉树的高度和满二叉树的节点数量的关系来判断节点数。

假设完全二叉树的高度为 h，如果左子树的高度等于右子树的高度，说明左子树是一棵满二叉树，可以直接计算节点数：2^h - 1。否则，我们继续递归地计算左右子树的节点数，直到遇到满二叉树为止。

具体实现

1. 首先，判断根节点是否为空，如果为空，则直接返回节点个数为 0。

2. 计算左子树和右子树的高度：

   我们可以用两个指针 left_child 和 right_child 分别从根节点开始，沿着左子树和右子树一直向左移动，直到到达叶子节点，此时的高度就是左子树和右子树的高度。

3. 判断是否为满二叉树：

   比较左子树和右子树的高度，如果相等，则说明左子树是满二叉树，直接计算满二叉树的节点数：2^h - 1，并返回结果。

4. 递归计算左子树和右子树的节点数：

   如果左子树的高度不等于右子树的高度，继续递归地计算左右子树的节点数，直到遇到满二叉树为止。

5. 返回节点个数：

   最后，将计算出的左子树节点数、右子树节点数以及根节点自身的节点数相加，就得到了完整的二叉树的节点数。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int countNodes(TreeNode* root) {
        if (root == nullptr)
            return 0;

        int left_height = 0, right_height = 0;
        TreeNode* left_child = root;
        TreeNode* right_child = root;

        // 计算左子树和右子树的高度
        while (left_child) {
            left_height++;
            left_child = left_child->left;
        }

        while (right_child) {
            right_height++;
            right_child = right_child->right;
        }

        // 如果左子树的高度等于右子树的高度，说明左子树是满二叉树
        if (left_height == right_height)
            return (1 << left_height) - 1;

        return 1 + countNodes(root->left) + countNodes(root->right);
    }
};

算法分析

时间复杂度分析：在最坏情况下，需要遍历完整个树的高度，所以时间复杂度为 O(log n)。

空间复杂度分析：在递归过程中，除了树的高度外，我们没有使用额外的空间，所以空间复杂度为 O(log n)。

方法三：迭代

算法分析

1. 首先，判断根节点是否为空，如果为空，则直接返回节点个数为 0。
2. 使用队列 que 来进行层序遍历：
   • 将根节点压入队列 que 中，表示从根节点开始进行层序遍历。
   • 利用循环，不断从队列中取出节点，并检查该节点的左右子节点，如果存在则将其压入队列。
3. 统计节点个数：
   • 使用 result 变量记录节点的数量。每次从队列中取出一个节点，就将 result 加 1，表示访问了一个节点。
4. 返回节点个数：
   • 最后，当队列为空，即遍历完成时，返回 result，即得到了节点的总数。

具体实现

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

算法分析

时间复杂度分析：在最坏情况下，每个节点都需要被访问一次，所以时间复杂度为 O(n)，其中 n 是二叉树的节点个数。

空间复杂度分析：在最坏情况下，队列中需要存储一层的节点，所以空间复杂度为 O(w)，其中 w 是二叉树最宽的层的节点个数。在最坏情况下，二叉树可能退化成链表，最宽的层会有 n/2 个节点，所以最坏情况下的空间复杂度为 O(n)。