102.二叉树的层序遍历：

这道题如果不看它要求的最终输出结果的形式，其实是非常简单的，麻烦就麻烦在它限定了输出的形式：要将每一层的数据放在一个列表中，如果仅仅是层次遍历的话，这么写就OK了：

def levelOrder(root):
	rootList = []
	lyst = []
	while rootList:
	    top = rootList.pop(0)
	    lyst.append(top.val)
	    if top.left is not None:
	        rootList.append(top.left)
	    if top.right is not None:
	        rootList.append(top.right)
	return lyst

现在面对现实吧，我一开始的想法是设置一个flag来标记当前的层数，但是不太好实现就没有深入想了，过了一会儿突然有了一个思路，我弄两个队列试试？两个队列分开存放两层的结点，首先有一个控制程序结束的循环，当两个队列都为空的时候就跳出来，一开始将头结点存到rootList1(队列1)，然后进入循环，如果某一个队列不为空，就一直检索队列的头结点，将其子结点存入rootList2，遍历完了之后将检索的值所存入的列表放入大列表中，如此循环就可以实现输出要求了，具体代码如下：

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        # self.preOrder(root)
        if root is None:
            return []
        rootList1 = [root]
        rootList2 = []
        lyst = []
        lystSon = []
        while rootList1 or rootList2:
            # flag = 0
            if rootList1:
                while rootList1:
                    top = rootList1.pop(0)
                    lystSon.append(top.val)
                    # flag = 1
                    if top.left is not None:
                        rootList2.append(top.left)
                    if top.right is not None:
                        rootList2.append(top.right)
            else:
                while rootList2:
                    top = rootList2.pop(0)
                    lystSon.append(top.val)
                    # flag = 2
                    if top.left is not None:
                        rootList1.append(top.left)
                    if top.right is not None:
                        rootList1.append(top.right)
            # if (rootList1 == [] and flag == 1) or (rootList2 == [] and flag == 2):
            lyst.append(lystSon)
            lystSon = []
        return lyst

运行效果：

还看见一个比较好的思路，它不是通过创建两个队列实现的，而是一个队列，那一个队列不是会曾与层之间弄混嘛？它是这么设计的：每一趟大循环，记一次队列的长度length，然后在本次大循环中，访问length次队列的头结点，然后子结点就依次存入这个队列的尾部，这样就分开了层与层之间的结点，具体代码如下：

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if root is None:
            return []
        q = [root]
        result = []
        while q:
            res = []
            for i in range(len(q)):
                node = q.pop(0)
                res.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            result.append(res)
        return result

看到一种使用递归实现的，欣赏一下代码：

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        levels = []
        if not root:
            return levels

        def helper(node, level):
            if len(levels) == level:
                levels.append([])
            levels[level].append(node.val)
            if node.left:
                helper(node.left, level+1)
            if node.right:
                helper(node.right, level+1)
        helper(root, 0)
        return levels

还看到一段思路和我代码思路差不多的，但是为啥别人的就这么精简呢？我得反思反思…：

import queue
class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        res = []
        if not root:    return res
        cur_level=[root]
        while cur_level:
            temp,next_level=[],[]
            for node in cur_level:
                temp.append(node.val)
                if node.left:
                    next_level.append(node.left)
                if node.right:
                    next_level.append(node.right)
            res.append(temp)
            cur_level=next_level
        return res