102. Binary Tree Level Order Traversal

题意：Given a binary tree, return the level order traversal of its nodes’ values. (ie, from left to right, level by level).

For example:
Given binary tree [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

return its level order traversal as:

[
  [3],
  [9,20],
  [15,7]
]

思路：层次遍历二叉树，需要一个队列和计数器来记录子节点个数，具体见代码:

from collections import deque
class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        dq ,ans = deque([root]), []
        cnt, printnum, tmp = 0, 1, []
        while dq:
            node = dq[0]
            print node.val
            tmp.append(node.val)
            if node.left:
                dq.append(node.left)
                cnt += 1
            if node.right:
                dq.append(node.right)
                cnt += 1
            dq.popleft()
            printnum -= 1
            if not printnum:
                ans.append(tmp)
                printnum = cnt
                cnt, tmp = 0, []
        return ans

后来无意间在Solution里看一段和很聪明的代码，利用python和列表推导式来巧妙的保存子节点：

def levelOrder(self, root):
    ans, level = [], [root]
    while root and level:
        ans.append([node.val for node in level])            
        level = [kid for n in level for kid in (n.left, n.right) if kid]
    return ans

当然，再贴上，利用递归的dfs方法：

def levelOrder(self, root):
        res = []
        self.dfs(root, 0, res)
        return res

    def dfs(self, root, level, res):
        if root:
            if len(res) < level + 1:
                res.append([])
            res[level].append(root.val)
            self.dfs(root.left, level+1, res)
            self.dfs(root.right, level+1, res)

还有利用栈的dfs：

def levelOrderBottom2(self, root):
    stack = [(root, 0)]
    res = []
    while stack:
        node, level = stack.pop()
        if node:
            if len(res) < level + 1:
                res.append([])
            res[level].append(root.val)
            stack.append((node.right, level+1))
            stack.append((node.left, level+1))
    return res

注意到本来dfs是遍历完根节点是先遍历左子树再遍历右子树，而不是这种层次遍历的方法，但是这里用了数组的索引来把遍历的方式限定死了。最后附一个利用队列的bfs的方法：

def levelOrderBottom(self, root):
    queue, res = collections.deque([(root, 0)]), []
    while queue:
        node, level = queue.popleft()
        if node:
            if len(res) < level+1:
                res.insert(0, [])
            res[-(level+1)].append(node.val)
            queue.append((node.left, level+1))
            queue.append((node.right, level+1))
    return res