剑指Offer 32. 【层序遍历】从上到下打印二叉树 / 107. 从下到上打印二叉树 / Python调用TreeNode！！！/ 打印 N 叉树的所有路径！！！

• 【题目列表】树的打印系列
  

• 257. 打印二叉树的所有【路径】 / 打印 N 叉树的所有路径 / 987. 二叉树的【垂序】遍历（H）

剑指Offer 32. 【层序遍历】从上到下打印二叉树

1. 【剑指 Offer 2 - I. 从上到下打印二叉树 I】
2. 【剑指 Offer 32 - II. 从上到下打印二叉树 II】
3. 【剑指 Offer 32 - III. 从上到下打印二叉树 III】

题解

1. 32 - I. 从上到下打印二叉树（层序遍历 BFS ，清晰图解）
2. 32 - II. 从上到下打印二叉树 II（层序遍历 BFS，清晰图解）
3. 32 - III. 从上到下打印二叉树 III（层序遍历 BFS / 双端队列，清晰图解）

思路

• I. 从上到下打印二叉树 I
  
  
• II. 从上到下打印二叉树 II
  
  
• III. 从上到下打印二叉树 III
  
  

代码

• I. 从上到下打印二叉树 I

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

class Solution:
    ### 1110 BFS + 双端队列（36 ms，13.7 MB）
    def levelOrder(self, root: TreeNode) -> List[int]:
        if not root: return [] 							 # 若为空树，则直接返回

        res, dq = [], collections.deque()
        dq.append(root)
        
        while dq: 										 # 当队列非空，则循环
            cur_node = dq.popleft() 					 # popleft()比pop(0)效率更高
            res.append(cur_node.val)

            if cur_node.left: dq.append(cur_node.left)   # 由于要求每层从左往右，因此先左后右
            if cur_node.right: dq.append(cur_node.right)

        return res

• II. 从上到下打印二叉树 II

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

class Solution:
    ### 1110 BFS + 双端队列（40 ms，13.8 MB）
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []                       # 若为空树，则直接返回

        res, dq = [], collections.deque()
        dq.append(root)

        while dq:                                    # 当队列非空，则循环
            tmp = []
            for _ in range(len(dq)):                 # 当前层打印循环，dq中元素数量即为当前层中元素数量
                node = dq.popleft()                  # popleft()比pop(0)效率更高
                tmp.append(node.val)

                if node.left: dq.append(node.left)   # 由于要求每层从左往右，因此先左后右
                if node.right: dq.append(node.right)

            res.append(tmp)

        return res

• III. 从上到下打印二叉树 III

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

class Solution:
    ### 1117 BFS + 双端队列（36 ms，13.8 MB）
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []

        res, dq = [], collections.deque([root])

        flag = True                                          # 定义flag变量，用于控制奇偶层数的打印顺序
        while dq:                                            # 当双端队列非空时进行循环
            tmp_dq = collections.deque()                     # 每次循环新建一个双端队列，方便左追加appendleft()
            
            for _ in range(len(dq)):
                cur_node = dq.popleft()                      # 队首元素出队（先进先出）
                if flag: tmp_dq.append(cur_node.val)         # 从左到右追加，右追加
                else: tmp_dq.appendleft(cur_node.val)        # 从右到左追加，左追加

                if cur_node.left: dq.append(cur_node.left)   # 左孩子非空，则追加
                if cur_node.right: dq.append(cur_node.right) # 右孩子非空，则追加
            
            res.append(list(tmp_dq))                         # 注意：需要将双端队列转化为列表！
            
            flag = not flag                                  # 每轮结束，flag取反

        return res

107. 从下到上打印二叉树

class Solution:
    def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
        levelOrder = list()
        if not root:
            return levelOrder
        
        q = collections.deque([root])
        while q:
            level = list()
            size = len(q)
            for _ in range(size):
                node = q.popleft()
                level.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            levelOrder.append(level)

        return levelOrder[::-1]