[leetcode] 104. maximum depth of binary tree

Given a binary tree, find its maximum depth.

The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

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


#Generate a binary tree by a list ( like, [1,2,None,4,5,6,None,8,9,10,11,12] ) and return the root node.   
def gen_Tree(val_list):
        if not val_list:
            return 
        root=TreeNode(val_list.pop(0))
        #print root.val
        le_list=[root]
        while val_list:
            tmp=le_list.pop(0)
            if val_list:
                tmp.left=TreeNode(val_list.pop(0))
                if tmp.left.val!=None:
                    le_list.append(tmp.left)
            if val_list:
                tmp.right=TreeNode(val_list.pop(0))
                if tmp.right.val!=None:
                    le_list.append(tmp.right)
            else:
                return root
        return root


# print the tree by level
def show_Tree(root):
    def print_fun(le):
        for i in le:
            if i!=None:
                print i.val,
            else:
                print 'None',
        print ''
    cur_le=[root]
    next_le=[]
    print_fun(cur_le)
    while cur_le:        
        tmp=cur_le.pop(0)
        if tmp!=None:# and tmp.val!=None:
            if tmp.left:
                next_le.append(tmp.left)
            else:
                next_le.append(None)
            if tmp.right:
                next_le.append(tmp.right)
            else:
                next_le.append(None)
        if not cur_le:
            cur_le=next_le
            print_fun(cur_le)
            next_le=[]
            if not cur_le:
                break            
    return


root=gen_Tree([1,2,None,4,5,6,None,8,9,10,11,12])
show_Tree(root)

1 
2 None 
4 5 None None 
6 None 8 9 
10 11 None None 12 None None None 
None None None None None None 

class Solution(object):
    def maxDepth(self,root):
        if not root:
            return 0
        queue,hei,max_hei=[],1,1
        queue.append((root,1))
        while queue:
            node,hei=queue.pop(0)
            max_hei=max(max_hei,hei)
            if node.left:
                queue.append((node.left,hei+1))
            if node.right:
                queue.append((node.right,hei+1))
        max_hei=max(max_hei,hei)
        return max_hei

Status: Accepted
Runtime: 68 ms
Ranking: beats 71.09%