[Leetcode] Binary search -- 222. Count Complete Tree Nodes-CSDN博客

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

Solution:

1. 1st naive method.
traverse every node, use bfs or dfs
or use recursive count; They are suitable for any types of tree.

2. 2nd method use recursively get left and right tree's height

if left and right-subtree height h_sub is the same, then it is full binary tree, so we can get the number of nodes = 2^h_sub -1
else recursively get left subtree node number and right subtree's node number
http://www.programcreek.com/2014/06/leetcode-count-complete-tree-nodes-java/

 1  def getLeftMostHeight(root):
 2             depthLeft = 0
 3             while(root):
 4                 root = root.left
 5                 depthLeft += 1
 6             return depthLeft
 7         
 8         
 9         def getRightMostHeight(root):
10             depthRight = 0
11             while(root):
12                 root = root.right
13                 depthRight += 1
14             return depthRight
15                
16         depthLeft = getLeftMostHeight(root)
17         depthRight = getRightMostHeight(root)
18         if depthLeft == depthRight:
19             return 2**(depthLeft) - 1
20         else:
21             return 1 + self.countNodes(root.left) + self.countNodes(root.right)

3. 3rd use binary search

I refer to this guy's blog. It is brilliant idea to do binary search
the tree height is h
the node number is the last layer number n_last + the full binary tree's number (2^(h-1)-1)
(1) the full binary tree could be determined by the traversing rightmost node from the root of whole tree
(2) how to determine the last layer number n_last is the key problem. we observe in the last layer there are continuous node from left to right represented by 111...11000..00, in which all "1" means nodes exist, "0" means nodes doesn't exist. all "1" are in the left of "0". Therefore, we need to find the position of the last "1" in the array using binary search.
the binary tree could be similar to binary array. The difference is how to decide the middle. ( we use the leftmost node of the right subtree from root to get the middle position and then determine to search the left subtree from root or the right subtree from the root.

reference: http://yucoding.blogspot.ca/2015/10/leetcode-question-question-count.html

 1    def findMiddleDepth(root):
 2             if root:
 3                 root = root.right
 4                 depth = 0
 5                 while (root):
 6                     root = root.left
 7                     depth += 1
 8                 return depth
 9             return 0
10             
11         if not root:
12             return 0
13         #get height of tree h, the full binary tree height is (h-1)
14         dep = 1
15         tmp = root
16         while (tmp.left):
17             dep += 1
18             tmp = tmp.left
19         
20         curr_root = root
21         curr_dep = 1
22         ans = 0
23         while (curr_dep < dep):
24             midPosHeight = findMiddleDepth(curr_root)
25             if midPosHeight + curr_dep == dep:
26                 curr_root = curr_root.right
27                 ans += 2**(midPosHeight-1)
28             else:
29                 curr_root = curr_root.left
30                 curr_dep += 1
31         return 2**(dep-1) + ans
32