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

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

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

返回其层次遍历结果：

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

解题思路

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

首先我们将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)

以下是这个过程的完整代码

class Solution:
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        ret = list()
        if root == None:
            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

同样的，这个问题我们可以使用list来解，而且更加简单。来我们通过在外层循环中设置一个临时list用来存储每一层的信息，这样就避免了使用tuple。内存循环就变成了for _ in range(len(q))，大家可以体会一下。

这里我们要注意一下，外部循环条件，我们不可以写成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, result = [root], []
        while any(q):
            tmp = list()
            for _ in range(len(q)):
                node = q.pop(0)
                tmp.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)

            result.append(tmp)
        return result

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

这个问题我们也可以写出递归的版本

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

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

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

猜你喜欢