算法工程师第十一天（理论基础 递归遍历 必须掌握 迭代遍历 统一迭代 层序遍历 ）

参考文献 代码随想录

一、二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

示例 1：

输入：root = [1,null,2,3]
输出：[1,2,3]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

示例 4：

输入：root = [1,2]
输出：[1,2]

示例 5：

输入：root = [1,null,2]
输出：[1,2]

提示：

• 树中节点数目在范围 [0, 100] 内
• -100 <= Node.val <= 100

递归：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """

        # 定义一个数组存放结果集
        ans = []
        # 判断是否为空
        
        # 递归
        def dfs(cur):
            if not cur: # 不能操作空的
                return ans
            ans.append(cur.val) # 中
            dfs(cur.left)  # 左
            dfs(cur.right)  # 右
        dfs(root)
        return ans

迭代：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        from collections import deque

        # 定义一个数组存放结果集
        ans = []
        # 判断是否为空
        if not root:
            return ans
        stack = deque()
        stack.append(root)
        # 递归
        while stack:
            tmp = stack.pop()
            ans.append(tmp.val)
            # 操作之前要判断是否为空
            if tmp.right:
                stack.append(tmp.right)
            if tmp.left:
                stack.append(tmp.left)
        return ans

        return ans

二、二叉树的后序遍历

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

示例 1：

输入：root = [1,null,2,3]
输出：[3,2,1]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

提示：

• 树中节点的数目在范围 [0, 100] 内
• -100 <= Node.val <= 100

递归：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        ans = []
        def dfs(cur):
            if not cur:  # 如果节点为空直接返回
                return []
            dfs(cur.left)
            dfs(cur.right)
            ans.append(cur.val)
        dfs(root)
        return ans        

迭代：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        from collections import deque
        stack = deque()
        ans = []
        if not root:
            return ans
        stack.append(root)
        while stack:
            tmp = stack.pop()
            ans.append(tmp.val)
            if tmp.left:
                stack.append(tmp.left)
            if tmp.right:
                stack.append(tmp.right)

        ans.reverse()
        return ans        

三、二叉树的中序遍历

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

示例 1：

输入：root = [1,null,2,3]
输出：[1,3,2]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

提示：

• 树中节点数目在范围 [0, 100] 内
• -100 <= Node.val <= 100

递归：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        ans = []
        def dfs(cur):
            if not cur:
                return
            dfs(cur.left)
            ans.append(cur.val)
            dfs(cur.right)
        dfs(root)
        return ans
        

迭代：这个和前序和后序有所不同，不同在，遍历顺序和处理顺序不一样

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        from collections import deque
        stack = deque()
        ans = []
        cur = root
        while stack or cur:  # 为什么要写2个，因为只要当cur和Stack都为零的时候就没有节点在循环了
            if cur != None:
                stack.append(cur)
                cur = cur.left
            else:
                tmp = stack.pop()
                ans.append(tmp.val)
                cur = tmp.right
        return ans
        

四、102. 二叉树的层序遍历

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        from collections import deque
        stack = deque()  # 使用的是队列（先进先出）
        ans = []
        if root:  # 判断是否为空
            stack.append(root)
        while stack:
            count = len(stack)  # 控制每层要输出的个数，就是没出要出队多少个元素
            tmp = []  # 记录每层的元素

            while count:  # len(stack) 为什么不写这个呢？因为下面会影响这个长度
                node = stack.popleft()  #为什么后面不用判断呢，因为已经判断Stack是否为空了
                # if node:  # 判断是否为空
                tmp.append(node.val)
                if node.left:
                    stack.append(node.left)
                if node.right:
                    stack.append(node.right)
                count -= 1
            ans.append(tmp)
        return ans