【面试常考算法】二叉树遍历系列总结

本篇主要记录二叉树的四种遍历方式（前序、中序、后序、层序）。

题目参考力扣144.94.145.102

树的遍历方式分为两种：深度优先遍历（DFS）和广度优先遍历(BFS)
DFS:先序遍历、中序遍历、后序遍历，往往使用递归或栈来解决
BFS：层次遍历，使用队列

树的节点定义：

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

先将前序、中序和后序模板在放一起。

一.递归法
递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。递归法是“自顶向下”的，使用递归最重要的就是搞清楚基线条件（base case）和递归条件（recursive case）是什么。在二叉树的遍历上，base case是树的节点为空，即已经遍历到叶子结点。

最简单直接的递归版方法如下：
递归法一

class Solution:
    def Traversal(self, root: TreeNode) -> List[int]:
    	if not root: return []
    	# 前序遍历
        return [root.val] + self.Traversal(root.left) + self.Traversal(root.right)
        # 中序遍历
        return self.Traversal(root.left) + [root.val] + self.Traversal(root.right)
        # 后序遍历
        return self.Traversal(root.left) + self.Traversal(root.right) + [root.val] 

递归法二

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        def dfs(root):
            if not root:return []
            # 先序遍历
            res.append(root.val)
            dfs(root.left)
            dfs(root.right)
            # 中序遍历
            dfs(root.left)
            res.append(root.val)
            dfs(root.right)
            # 后序遍历
            dfs(root.left)
            dfs(root.right)
            res.append(root.val)
        res = []
        dfs(root)
        return res 

递归法的时间复杂度O（n），n为二叉树的几点个数，空间复杂度为O（n）。空间复杂度取决于递归的栈深度。

迭代法
迭代法为自底向上的方法。循环条件是辅助栈stack非空或root非空，因为只要有一个非空就是节点还没遍历完。对于中序遍历来说，遍历顺序为左→根→右。循环体内容为：

• 先将根节点加到stack中，然后一直去遍历左节点，一直遍历到空为止；
• 如果为空了，也就是root是空节点了，说明当前子树的左节点已经遍历完了，开始将左节点值加入到res中，从stack中弹出最近遍历到的节点，将节点值加到res中后让root=root.right。前中后序遍历只是加入res的时间不同。

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        # 借用辅助栈完成迭代法
        res, stack = [], []
        #前序遍历
        while stack or root:
            if root:
                stack.append(root)
                res.append(root.val)
                root = root.left
            else:
                root = stack.pop()
                root = root.right
        return res
        #中序遍历
        while stack or root:
            if root:
                stack.append(root) 
                root = root.left
            else:
                root = stack.pop()
                res.append(root.val)
                root = root.right
        return res
        #后序遍历
        while stack or root:
            if root:
                stack.append(root)
                res.append(root.val)
                root = root.right
            else:
                root = stack.pop()
                root = root.left
        return res[::-1] 

后序遍历顺序为左→右→根，其实就是按照根→右→左的顺序的逆序。所以先类似于前序遍历的方式将根→右→左写出来，最后返回逆序即可。
时间复杂度为O（n），空间复杂度O（n）

最后一个层序遍历
使用队列保存每层的所有节点，每次把队列里的原先节点出队，再把出队元素的非空左右子节点入队。

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:return []
        res = []
        d = collections.deque()
        d.append(root)
        while d:
            n = len(d)
            tmp = []
            for i in range(n):
                node = d.popleft()
                tmp.append(node.val)
                if node.left:
                    d.append(node.left)
                if node.right:
                    d.append(node.right)
            res.append(tmp)
        return res

每个节点进队、出队各一次，时间复杂度O（n）
队列中元素个数不超过n个，空间复杂度O（n）

明明是原创，但是审核非不通过。无语~