BFS-32：从上到下打印二叉树（剑指offer2）102. 二叉树的层序遍历

1、题目描述

102. 二叉树的层序遍历 - 力扣（LeetCode）

从上往下打印出二叉树的每个节点，同层节点从左至右打印。

2、代码详解

双端队列

相当于按层遍历, 中间需要队列做转存，引入一个队列即可。
推广：有向图的广度优先遍历也是基于队列的。

# -*- coding:utf-8 -*-
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class Solution:
    # 返回从上到下每个节点值列表，例：[1,2,3]
    def PrintFromTopToBottom(self, root):
        queue = []  # 双端队列,存储TreeNode
        result = []  # 存储弹出的队头值
        if root == None:
            return []

        queue.append(root)
        while len(queue) > 0:
            queueHead = queue.pop(0)  # 弹出队首的树节点（出队）
            result.append(queueHead.val)  # 存储被弹出树节点的值
            # 左右孩子节点入队
            if queueHead.left:
                queue.append(queueHead.left)
            if queueHead.right:
                queue.append(queueHead.right)
        return result


pNode1 = TreeNode(8)
pNode2 = TreeNode(6)
pNode3 = TreeNode(10)
pNode4 = TreeNode(5)
pNode5 = TreeNode(7)
pNode6 = TreeNode(9)
pNode7 = TreeNode(11)

pNode1.left = pNode2
pNode1.right = pNode3
pNode2.left = pNode4
pNode2.right = pNode5
pNode3.left = pNode6
pNode3.right = pNode7

S = Solution()
print(S.PrintFromTopToBottom(pNode1))

3、进阶：LeetCode102. 二叉树的层序遍历（二维list输出）

与剑指offer（[8, 6, 10, 5, 7, 9, 11]）的区别是

输出：[[8], [6, 10], [5, 7, 9, 11]]

加入两个变量：level_size和current_level，便可以按层分割

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

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        queue = []  # 双端队列,存储TreeNode
        if root == None:
            return []
 
        queue.append(root)
        result = []  # 存储弹出的队头值

        while len(queue) > 0:
            level_size = len(queue)  # 每层
            current_level = []  # 当前层：一层存在一个list中，使用双端队列方便从左或从右添加元素
 
            for _ in range(level_size):  # 仅pop(0)出当前层的
                queue_head = queue.pop(0)  # 弹出队首的树节点（出队）
                current_level.append(queue_head.val)  # 存储被弹出树节点的值
                # 左右孩子节点入队
                if queue_head.left:
                    queue.append(queue_head.left)
                if queue_head.right:
                    queue.append(queue_head.right)
 
            result.append(current_level)
 
        return result

def main():
    # 构建一个简单的二叉树
    #       3
    #      / \
    #     9  20
    #       /  \
    #      15   7
    root = TreeNode(3)
    root.left = TreeNode(9)
    root.right = TreeNode(20)
    root.right.left = TreeNode(15)
    root.right.right = TreeNode(7)

    s = Solution()
    result = s.levelOrder(root)
    print(result)

if __name__ == "__main__":
    main()

另附一种模板写法

102. 二叉树的层序遍历 - 力扣（LeetCode）

复杂度分析

记树上所有节点的个数为 n。

时间复杂度：每个点进队出队各一次，故渐进时间复杂度为 O(n)。
空间复杂度：队列中元素的个数不超过 n 个，故渐进空间复杂度为 O(n)。