二叉树的层次遍历小结

• 二叉树普通的层次遍历也即广度优先遍历（BFS），横向遍历，将每个节点按层的顺序依次打印出来。

因此我们需要一个队列，在处理一个结点时，函数先将其左右子结点顺序加入队列。这样实现的就是对每层结点从左到右的遍历。为了防止可能把一些空树加入队列浪费存储空间，需要在操作前检查子节点的存在情况。

一、【LeetCode 102】二叉树的层次遍历

1.题目描述

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

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

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果为：

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

2.思路

需要一个数组res保存每一层的节点值；同样需要一个队列，来存储每一层的节点，只要队列不为空，说明还要继续遍历，此处便需要一个while循环。

• 计算出每一层的长度，也即每层的节点个数；定义一个列表list用来存储当前层的节点值。

• • 遍历当前层，将当前层的节点从队列中依次取出并将值添加进list；
• • 然后判断当前节点的左右孩子是否存在，若存在也依次添加进队列中。
• 当前层的节点遍历完毕就跳出内层循环for循环，将得到的list添加进res中。
  当队列为空时，说明遍历结束，退出循环返回res即可得到每层结果的层次遍历。

3.代码

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []    
        res = []
        queue = [root]
        while queue:
            n = len(queue)
            list = []
            for i in range(0, n):
                cur = queue.pop(0)
                list.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            res.append(list)
        return res

二、【LeetCode 107】二叉树的层次遍历II

1.题目描述

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

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

    3
   / \
  9  20
    /  \
   15   7

返回其自底向上的层次遍历为：

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

2.思路

思路跟上面的102题一模一样，只是在最后的添加方式有点区别：因为要自底向上输出，而我们是自顶向下遍历，所以将每层的节点值追加到数组中时要使用insert方法levels.insert(0, res)，头插法即可得到正确的结果。

3.代码

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
        levels = []
        if not root:
            return []
        queue = [root]
        node = root
        while queue:
            res = []
            n = len(queue)
            for i in range(0, n):
                node = queue.pop(0)
                res.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            levels.insert(0, res)   #此处添加方式不同，不再是append
        return levels

三、【LeetCode 103】二叉树的锯齿形层次遍历

1.题目描述

给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

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

    3
   / \
  9  20
    /  \
   15   7

返回锯齿形层次遍历如下：

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

2.思路

思路也和102题类似，不过多了一个level变量，用来判断当前处于奇数层还是偶数层，若处于奇数层则正常将节点值追加到列表res中res.append(node.val)；若处于偶数层则需要使用头插法res.insert(0, node.val)。因为题干要求先从左往右，再从右往左进行遍历（也就是在奇数层是从左往右，在偶数层是从右往左）

3.代码

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
        levels = []
        if not root:
            return []
        queue = [root]
        node = root
        level = 1
        while queue:
            res = []
            n = len(queue)
            for i in range(0, n):
                node = queue.pop(0)
                if level % 2 == 1: 
                    res.append(node.val)
                else:
                    res.insert(0, node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            levels.append(res)
            level += 1
        return levels