題目如下：

Given a binary tree, write a function to get the maximum width of the given tree. The width of a tree is the maximum width among all levels. The binary tree has the same structure as a full binary tree, but some nodes are null.

The width of one level is defined as the length between the end-nodes (the leftmost and right most non-null nodes in the level, where the null

 nodes between the end-nodes are also counted into the length calculation.

Example 1:

Input: 

           1
         /   \
        3     2
       / \     \  
      5   3     9 

Output: 4
Explanation: The maximum width existing in the third level with the length 4 (5,3,null,9).

Example 2:

Input: 

          1
         /  
        3    
       / \       
      5   3     

Output: 2
Explanation: The maximum width existing in the third level with the length 2 (5,3).

Example 3:

Input: 

          1
         / \
        3   2 
       /        
      5      

Output: 2
Explanation: The maximum width existing in the second level with the length 2 (3,2).

Example 4:

Input: 

          1
         / \
        3   2
       /     \  
      5       9 
     /         \
    6           7
Output: 8
Explanation:The maximum width existing in the fourth level with the length 8 (6,null,null,null,null,null,null,7).

Note: Answer will in the range of 32-bit signed integer.

解題思路：對於一個二叉樹，我們可以按層序遍歷的順序給每一個節點定義一個順序索引，例如根節點是第一個遍歷的節點，那麼索引是1。很顯然，根節點的左節點的索引是2，右節點是3。二叉樹的父節點與左右子節點的索引滿足這麼一個規律的，如果父節點的索引值是i，那麼左節點是2*i，右節點是2*i+1。所以，只需要用遍歷二叉樹，計算出每一層最左邊的節點和最右邊節點的索引的差值即可。

程式碼如下：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    dic = {}
    res = 0
    def traverse(self,node,level,inx):
        if node == None:
            return 
        if level not in self.dic:
            self.dic[level] = [inx]
        else:
            if len(self.dic[level]) == 1:
                self.dic[level].append(inx)
            else:
                self.dic[level][1] = inx
            self.res = max(self.res,self.dic[level][1] - self.dic[level][0])
        if node.left != None:
            self.traverse(node.left,level + 1 ,inx*2)
        if node.right != None:
            self.traverse(node.right, level + 1, inx * 2 + 1)

    def widthOfBinaryTree(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        self.dic = {}
        self.res = 0
        self.traverse(root,0,1)
        return self.res + 1