【leetcode】662. Maximum Width of Binary Tree

题目如下：

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