Leetcode 102:二叉树的层次遍历（最详细解决方案！！！）

给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。

例如:
给定二叉树: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：

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

解题思路

这是一个BFS问题，首先可以想到就是通常的解法。我们可以使用queue解决，在python中，我们可以通过from queue import Queue。也可以使用list来解决，不过在使用list的时候要注意，我们如果pop操作的话，要添加一个参数pop(0)，表示我们pop最前面的元素。

这里我们要注意一下，外部循环条件，我们不可以写成while q:，因为当输入是[]，这个时候q=[[]]，python对这个结果的判定是True，参看这篇文章python中的and和or。我们这里可以使用while any(q)，具体实现如下。

class Solution:
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        q, res = [root], []
        while any(q):
            cur = list()
            len_q = len(q)
            for _ in range(len_q):
                node = q.pop(0)
                cur.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            res.append(cur)
        return res

当然了，我们也可以先使用if root:进行判断，而且我也更加推荐这种写法。

class Solution:
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return list()
        
		......

这种解法非常无聊，没有新意。这个问题我们也可以通过DFS来解，我们只需要遍历的过程中记录深度信息即可。

首先我们将root入队，并且我们也要同时保存root的层信息，所以我这里使用了一个tuple

q : (root, 0)

接着我们进入一个循环体，我们判断q.empty()。如果非空，我们就执行循环体中的内容。

首先获取q的队首元素，接着我们要判断level == len(ret)（队首元素的level是不是等于返回列表的长度）

ret : []   
q : (root, 0)

我们发现相等，所以我们就要添加一个list

ret : [[]]

然后将ret[level].append(队首元素first的val)。

ret : [[3]]

接着我们判断队首元素的左右孩子是不是空，如果不是空，我们分别添加到q的后面，并且同时tuple中的level+1。

q : (9, 1) (20, 1)

以下是这个过程的完整代码（我们通过queue来实现）

class Solution:
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        ret = list()
        if not root:
            return ret

        from queue import Queue
        q = Queue()
        q.put((root, 0))
        while not q.empty():
            node, level = q.get()
            if level == len(ret):
                ret.append([])
                
            ret[level].append(node.val)
            if node.left != None:
                q.put((node.left, level + 1))
            if node.right != None:
                q.put((node.right, level + 1))

        return ret

这个问题我们也可以写出递归的版本，而且非常简洁。

class Solution:
    def _levelOrder(self, level, result, node):
        if node:
            if level == len(result):
                result.append([])
                
            result[level].append(node.val)
            self._levelOrder(level+1, result, node.left)
            self._levelOrder(level+1, result, node.right)

    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        level, result = 0, list()
        self._levelOrder(level, result, root)
        return result 

我将该问题的其他语言版本添加到了我的GitHub Leetcode

如有问题，希望大家指出！！！