[LeetCode] 222. Count Complete Tree Nodes

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

Note:

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 2h nodes inclusive at the last level h.

Example:

Input: 
    1
   / 
  2   3
 /   /
4  5 6

Output: 6

完全二叉树的节点个数。题意是给一个完全二叉树，请求出节点个数。

比较直观的思路是可以用递归。因为一个完美二叉树的节点个数是2^h - 1，2的h次方 - 1，h是树的高度。如果根节点的左子树和右子树的高度一样，则说明左子树一定为满二叉树。如果左子树和右子树的高度不一样，则右子树一定不是满二叉树，左子树也有可能不是满二叉树，就需要递归到更小的子树去看到底哪个子树不是满二叉树。

时间O(n)

空间O(logn) - O(h) - 树的高度

Java实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int countNodes(TreeNode root) {
        int left = leftDepth(root);
        int right = rightDepth(root);
        // 如果根节点的左子树深度等于右子树深度，则说明左子树为满二叉树
        // 否则就要递归去找到底哪个子树不是满二叉树
        if (left == right) {
            return (int) Math.pow(2, left) - 1;
        } else {
            return 1 + countNodes(root.left) + countNodes(root.right);
        }
    }

    private int leftDepth(TreeNode root) {
        int depth = 0;
        while (root != null) {
            root = root.left;
            depth++;
        }
        return depth;
    }

    private int rightDepth(TreeNode root) {
        int depth = 0;
        while (root != null) {
            root = root.right;
            depth++;
        }
        return depth;
    }
}

注意这个题的tag是binary search二分法，同时二分法也是最优解，所以这里我也给出二分法的解法，参考了这个帖子。思路是首先拿到树的最大深度，这个不难，只要不停地往左孩子遍历就行。其次，如果是一个满二叉树（complete binary tree），节点数是2^depth - 1。按照例子，如果是一个高度为3的树，节点个数就是2^3 - 1 = 7；同时最后一层的节点数应该是2^(depth - 1) = 2^2 = 4。

但是如果只是一个完全二叉树，最后一层的节点数很有可能是缺失的，此时就需要用二分法找最后一层到底有几个节点了。这里需要写一个helper函数帮助做二分法，因为每一层的节点数是跟当前的深度有关所以当前层的节点数的范围应该在0 ~ (2^depth - 1)之间。所以二分法找的时候，比如一个高度为3的树如果是满的，理论上最低一层应该有8个节点，则去判断是否有第4个节点，若有则往右子树走，若没有则往左子树走。最后helper函数返回的是最后一层处于位置i的节点是否存在。

最后着重解释一下exist函数。还是给定了上下界left = 0, right = 2^depth - 1。这个函数是为了检查某一个节点是否存在的。检查的方法其实是类似DFS，从深度为0的地方开始，在已经知道节点index的情况下，带入tree去检查，如果index大于当前层中间的node，则去右子树看，反之则去左子树看。

时间O(logn * logn)

空间O(1)

Java实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int countNodes(TreeNode root) {
        // corner case
        if (root == null) {
            return 0;
        }
        int d = computeDepth(root);
        if (d == 0) {
            return 1;
        }

        // normal case
        int left = 1;
        int right = (int) Math.pow(2, d) - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (exists(root, d, mid)) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return (int) Math.pow(2, d) - 1 + left;
    }

    private int computeDepth(TreeNode root) {
        int depth = 0;
        while (root.left != null) {
            depth++;
            root = root.left;
        }
        return depth;
    }

    private boolean exists(TreeNode root, int depth, int index) {
        int left = 0;
        int right = (int) Math.pow(2, depth) - 1;
        int mid;
        for (int i = 0; i < depth; i++) {
            mid = left + (right - left) / 2;
            if (index <= mid) {
                root = root.left;
                right = mid;
            } else {
                root = root.right;
                left = mid;
            }
        }
        return root != null;
    }
}

LeetCode 题目总结