I found an interesting problem on https://leetcode.com/problems/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.

I tried it in Python, but could not do it. Can you solve it?
class Solution:
     
     
     def widthOfBinaryTree(self, root):
         """
         :type root: TreeNode
         :rtype: int
         """
         if not root: return 0
 
         maxlen=1
         start=1
         end=1
         tlen=1
         l=[[root,1]]
         
         while tlen:
             llen=tlen
             tlen=0
             while llen:
                 cur=l.pop(0)
                 llen-=1
                 if cur[0]:
                     l.append([cur[0].left,2*cur[1]-1])
                     l.append([cur[0].right,2*cur[1]])
                     tlen+=2
 
             if len(l)>0:
                 for item in reversed(l):
                     if item[0]:
                         end=item[1]
                         break
                 if end != item[1]: return maxlen
                 
                 for item in l:
                     if item[0]:
                         start=item[1]
                         break;
                 
                 end = end - start + 1
                 if(end > maxlen):  maxlen=end
                 
                 start=end=-1;
                 
         return maxlen