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

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

1、题目

题目链接：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) 的简单解决方案。你可以设计一个更快的算法吗？

2、递归法（通用）

思路

代码

#include <iostream>

using namespace std;

//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 {
private:
    int getNodesNum(TreeNode* cur) {
        // 如果当前节点为空，则返回0
        if (cur == nullptr) {
            return 0;
        }
        // 递归计算左子树的节点数
        int leftNum = getNodesNum(cur->left);
        // 递归计算右子树的节点数
        int rightNum = getNodesNum(cur->right);
        // 当前树的节点数为左子树节点数 + 右子树节点数 + 当前节点1个
        int treeNum = leftNum + rightNum + 1;
        // 返回当前树的节点数
        return treeNum;
    }

public:
    int countNodes(TreeNode* root) {
        return getNodesNum(root);
    }
};

int main() {
    Solution s;
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);
    cout << s.countNodes(root) << endl;
    return 0;
}

复杂度分析

• 时间复杂度：O(n)
• 空间复杂度：O(log n)，算上了递归系统栈占用的空间

3、递归法（精简版）

思路

代码

class Solution {
public:
    int countNodes(TreeNode* root) {
        // 如果根节点为空，返回0
        if (root == nullptr) return 0;
        // 返回1（当前节点）加上左子树的节点数加上右子树的节点数
        return 1 + countNodes(root->left) + countNodes(root->right);
    }
};

复杂度分析

• 时间复杂度：O(n)
• 空间复杂度：O(log n)，算上了递归系统栈占用的空间

4、迭代法

思路

代码

class Solution {
public:
    int countNodes(TreeNode* root) {
        // 创建一个队列用于存储节点指针
        queue<TreeNode*> que;
        // 如果根节点不为空，则将其加入队列
        if (root != nullptr) {
            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)
• 空间复杂度：O(n)

5、递归法（利用完全二叉树性质）

思路

代码

class Solution {
public:
    int countNodes(TreeNode* root) {
        // 如果根节点为空，返回0
        if (root == nullptr) {
            return 0;
        }

        // 获取左子树和右子树
        TreeNode* left = root->left;
        TreeNode* right = root->right;

        // 初始化左子树和右子树的深度为0
        int leftDepth = 0, rightDepth = 0;

        // 计算左子树的深度
        while (left) {
            left = left->left;
            leftDepth++;
        }

        // 计算右子树的深度
        while (right) {
            right = right->right;
            rightDepth++;
        }

        // 如果左子树和右子树的深度相等
        if (leftDepth == rightDepth) {
            // 返回完全二叉树的节点总数（2的左子树深度次方减1）
            return (2 << leftDepth) - 1;
        }

        // 如果左子树和右子树的深度不相等，则递归计算左子树和右子树的节点总数，并加上根节点
        return countNodes(root->left) + countNodes(root->right) + 1;
    }
};

复杂度分析

• 时间复杂度：O(log n × log n)
• 空间复杂度：O(log n)