Count Complete Tree Nodes -- leetcode

Given a complete binary tree, count the number of nodes.

Definition of a complete binary tree from Wikipedia:
In a complete binary tree every level, except possibly the last, is completely filled, and all nodes in the last level are as far left as possible. It can have between 1 and 2^h nodes inclusive at the last level h.

基本思路：折半

判断当前子树是否为满二叉树，如果是，则应用公式，根据高度求结点。2 ^ (h+1) - 1,  h 从0 开始，即根为0层

如果不是满二叉树，则递归求出左子树和右子树的结点树。

判断是否为满二叉树，是通过从左子树往下遍历求高度，和通过右子树往下求高度，最后作比较完成的。

每次折半时，左子树和右子树中，必有一个是满二叉树。故可每次完成一半结点的统计。

时间复杂度为O(log(n)^2)

在leetcode上实际执行时间为128ms。

/** * Definition for a binary tree node. * struct TreeNode { *     int val; *     TreeNode *left; *     TreeNode *right; *     TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public:    int countNodes(TreeNode* root) {        if (!root) return 0;        int level = -1;        TreeNode *left = root;        TreeNode *right = root;        while (right) {            ++level;            left = left->left;            right = right->right;        }        if (!left)            return (1 << level+1) - 1;        else            return 1 + countNodes(root->left) + countNodes(root->right);    }};

算法二，折半

算法一中，每次递归时，都会进行两次求高度运算。

此算法将省去一次高度运算。在进行子树细分时，高度是逐渐递减的，因此左边子树的高度无须每次进行运算。

但是思路与算法一略有差别。

1. 求出右子树的高度。

2. 如果此高度与左子树的高度一致。 则说明左子树是，一棵满二叉树。左子树的节点数可以用公式求解。只需要再对右子树继续进行递归折半。

3. 如果此高度与左子树的高度不一致。 则说明右子树，是一棵满二叉树。右子树的节点数可以用公式求解。然后再对左子树进行递归折半。

在leetcode上实际执行时间为96ms。

class Solution {public:    int countNodes(TreeNode* root) {        return count(root, height(root));    }        int count(TreeNode* root, int level) {        if (!root) return 0;        int rightH = height(root->right);        if (rightH == level-1)            return (1 << level) + count(root->right, level-1);        else            return (1 << level-1) + count(root->left, level-1);    }        int height(TreeNode* root) {        int level = -1;        while (root) {            ++level;            root = root->left;        }        return level;    }};

最后附上自己的第一版算法，留作纪念

在leetcode上实际执行时间为120ms。

基本思路，基于折半。

同时，关注点，在于对最后一层的节点数的统计。代码中，count是统计最后一层的节点数。

每一层递归中，统计当前子树，最下节点，是否达到指定的高度。

class Solution {public:    int countNodes(TreeNode* root) {        if (!root) return 0;        if (!root->left) return 1;        int total = 0;        int nodes = 1;        int level = 1;        TreeNode *p = root;        while (p->left) {            total += nodes;            p = p->left;            nodes <<= 1;            ++level;        }                return total + count(root, nodes, level);    }        int count(TreeNode* root, int last_level_nodes, int level) {        if (is_complete(root, level))            return last_level_nodes;                last_level_nodes >>= 1;        --level;        int total = 0;        if (root->left)            total = count(root->left, last_level_nodes, level);        if (total == last_level_nodes && root->right)            total += count(root->right, last_level_nodes, level);                return total;    }        bool is_complete(TreeNode* root, int level) {        while (root && level) {            root = root->right;            --level;        }        return !root && !level;    }};