剑指 Offer 32 - I. 从上到下打印二叉树

题目链接：https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-lcof/

Description

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

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

返回：

[3,9,20,15,7]

提示：

节点总数 <= 1000

Answer

需要注意，该问题的二叉树是已经构造好了的，我们只需要将其以层级的方式遍历出来即可。学过二叉树的肯定听过先序遍历，中序遍历，后序遍历以及层级遍历。之所以讲这道题，也是想总结一下，提供这四种遍历的源代码。由于这四种遍历都能通过循环与递归实现，都安排上，以供后期翻阅。

层级遍历（循环）

要求按照层级顺序遍历该二叉树，学过数据结构应该很容易想到队列，先进先出的数据结构嘛，很符合该题的设定。时间复杂度$O(n)$，空间复杂度$O(n)$。OK，show you the code.

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

class Solution:
    # 这里的tree是已经生成了的二叉树。
    def levelOrder(self, root: TreeNode) -> List[int]:
        if root == None:
            return []
        queue = []
        result = []
        left = 0
        right = 1
        queue.append(root)

        while left < right:
            left_node = queue[left]
            left += 1
            result.append(left_node.val)
            if left_node.left:
                queue.append(left_node.left)
                right += 1
            if left_node.right:
                queue.append(left_node.right)
                right += 1
        return result

层级遍历（递归）

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

class Solution:
    # 这里的tree是已经生成了的二叉树。
    def levelOrder(self, root: TreeNode) -> List[int]:
        def helper(node, level):
            if not node:
                return
            else:
                # 参数加上level，为了记录当前层数
                # 不管递归多深，level都记录了层数，将值送进相应level的数组就好。
                sol[level-1].append(node.val)
                if len(sol) == level:  # 遍历到新层时，只有最左边的结点使得等式成立
                    sol.append([])
                helper(node.left, level+1)
                helper(node.right, level+1)
        sol = [[]]
        helper(root, 1)
        result = []
        for level_list in sol:
            for val in level_list:
                result.append(val)
        return result

先序遍历（递归）

如下的中序与后序遍历的递归代码基本相似，可以对比学习。

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

class Solution:
    # 这里的tree是已经生成了的二叉树。
    def levelOrder(self, root: TreeNode) -> List[int]:
        def preorder(root):
            if not root:
                return [] 
            else:
                result.append(root.val)
                preorder(root.left)
                preorder(root.right)
        result = []
        preorder(root)
        return result

先序遍历（循环）

循环实现的理解有点难，传送门 https://www.cnblogs.com/bjwu/p/9284534.html ，了解更多代码细节。

class Solution:
    # 这里的tree是已经生成了的二叉树。
    def levelOrder(self, root: TreeNode) -> List[int]:
        # 使用循环来做先序遍历还是很复杂的，主要通过stack的概念来实现
        stack = []
        result = []
        cur_node = root
        while stack or cur_node:
            if cur_node:
                result.append(cur_node.val)
                stack.append(cur_node.right)
                cur_node = cur_node.left
            else:
                cur_node = stack.pop()
        return result

中序遍历（递归）

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

class Solution:
    # 这里的tree是已经生成了的二叉树。
    def levelOrder(self, root: TreeNode) -> List[int]:
        def inorder(root):
            if not root:
                return [] 
            else:
                inorder(root.left)
                result.append(root.val)
                inorder(root.right)
        result = []
        inorder(root)
        return result

中序遍历（循环）

class Solution:
    # 这里的tree是已经生成了的二叉树。
    def levelOrder(self, root: TreeNode) -> List[int]:
        # 使用循环来做中序遍历还是很复杂的，主要通过stack的概念来实现
        stack = []
        result = []
        cur_node = root
        while stack or cur_node:
            if cur_node:
                stack.append(cur_node)
                cur_node = cur_node.left
            else:
                cur_node = stack.pop()
                result.append(cur_node.val)
                cur_node = cur_node.right
        return result

后序遍历（递归）

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

class Solution:
    # 这里的tree是已经生成了的二叉树。
    def levelOrder(self, root: TreeNode) -> List[int]:
        def postorder(root):
            if not root:
                return [] 
            else:
                postorder(root.left)
                postorder(root.right)
                result.append(root.val)
        result = []
        postorder(root)
        return result

后序遍历（循环）

class Solution:
    # 这里的tree是已经生成了的二叉树。
    def levelOrder(self, root: TreeNode) -> List[int]:
        # 使用循环来做后序遍历还是很复杂的，主要通过stack的概念来实现
        # 与先序相比，相当于将如下代码的left改成right,将right改成left
        # 最后将result逆序
        stack = []
        result = []
        cur_node = root
        while stack or cur_node:
            if cur_node:
                result.append(cur_node.val)
                stack.append(cur_node.left)
                cur_node = cur_node.right
            else:
                cur_node = stack.pop()
        # 如下代码将result逆序
        return result[::-1]