二叉树的层次遍历--leetcode习题总结

102. Binary Tree Level Order Traversal

给定一棵二叉树，层次遍历后返回一个二维列表，把每一层的节点作为一个列表返回
输入输出如下图所示：

第一种写法：复杂但可控

class Solution(object):
    def levelOrder(self, root):
    	queue = [root] if root else []
        res = []
        level_k = [] # 第k层的节点的值
        width = 1 # 第k层的节点数
        while queue:
            cur = queue.pop()
            level_k.append(cur.val)
            width -= 1
            if cur.left: queue = [cur.left] + queue  # 队列
            if cur.right: queue = [cur.right] + queue

            if width == 0:
                width = len(queue)  #更新下一层节点个数
                res.append(level_k)
                level_k = []
               
        return res

第二种写法：简单高效

class Solution(object):
    def levelOrder(self, root):
        queue = [root] if root else []
        res = []
        
        while queue:
            res.append([node.val for node in queue]) #把当前层的节点值放入一个列表
            queue = [kid for n in queue for kid in (n.left, n.right) if kid] # 更新下一层节点
        return res

解释的三行代码的功能与一行代码不同,只是可以这样理解上述一行代码是如何运行的!!!

 queue = [kid for n in queue for kid in (n.left, n.right) if kid]  解释如下:
  for n in queue:  
 	   for kid in (n.left,n.right):
   			if kid: queue.append(kid)

不管是时间开销还是空间开销都是第二种方法更优秀,而且写法很简单明了,
建议使用第二种方法写!!!

107. Binary Tree Level Order Traversal II

还是一样的思路，先层次遍历，然后通过切片来进行逆序

class Solution(object):
    def levelOrderBottom(self, root):
        queue = [root] if root else []
        res = []
        while queue:  # 层次遍历
            res.append([node.val for node in queue])
            queue = [kid for n in queue for kid in (n.left, n.right) if kid]
        return res[::-1] # 从最后一个到最开始，步长为-1

429. N-ary Tree Level Order Traversal

给定一颗n叉数,层次遍历后,返回一个二维列表,每一层的节点值为一个列表
输入输出如下图所示:

代码如下:

class Solution(object):
    def levelOrder(self, root):
        queue = [root] if root else [] # List
        res = []
        # 出问题的地方在于root.children是一个list，通过for循环把list中的节点取出来才行
        while queue:
            res.append([node.val for node in queue])  # 一层
            queue = [child for node in queue for child in node.children]    # 下一层节点覆盖上一层
        return res

199. Binary Tree Right Side View

题目：给定一棵二叉树，假设你站着这棵树的最右边，返回然后你看到每一层的第一个节点，即返回层次遍历的每一层的最后一个节点。输入输出如下所示：

代码如下：

class Solution(object):
    def rightSideView(self, root):
        queue = [root] if root else []
        res = []
        while queue:
            res.append(queue[-1].val)  # 返回每一层的最后一个节点值就行
            queue = [kid for n in queue for kid in (n.left,n.right) if kid]
            
        return res

103. Binary Tree Zigzag Level Order Traversal

题意：层次遍历二叉树，奇数层以从左到右的顺序返回，偶数层以从右到左的顺序返回，最终返回一个二维数组。

方法一：记录层数后逆序

class Solution(object):
    def zigzagLevelOrder(self, root):
        
        queue = [root] if root else []
        res = []
        level = 1
        
        while queue:
            Zigzag = [node.val for node in queue]
            if level % 2 == 0: # 偶数层 
                Zigzag.reverse()
            res.append(Zigzag)
            queue = [kid for n in queue for kid in (n.left,n.right) if kid]
            level += 1
        
        return res

方法二：切片来控制顺序与逆序

使用切片的方式来逆序数组，比直接调用reverser()函数会好一点，花时间时间更少

if not root: return []
res, level, direction = [], [root], 1
while level:
    res.append([n.val for n in level][::direction])
    direction *= -1
    level = [kid for node in level for kid in (node.left, node.right) if kid]
return res

662. Maximum Width of Binary Tree

题意：给定一棵完全二叉树，求树中的某一层的最大宽度。

class Solution(object):
    def widthOfBinaryTree(self, root):
        if not root: return 0
        width = 0
        queue = [(root, 1)]  # 完全二叉树按照1为开始序号
        
        while queue:
            width = max(width, queue[-1][1]-queue[0][1]+1)  # 最右边节点序号-最左边节点序号
            next_level = []
            for node, num in queue:
                if node.left: # Make sure to not put the Null nodes
                    next_level.append((node.left, num*2))
                if node.right:
                    next_level.append((node.right, num*2+1))
            queue = next_level
        return width