代码随想录算法训练营第十三天 | 二叉树遍历

深搜

前中后序遍历的递归写法：

递归写法很容易，直接给代码

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []

        def dfs(root):
            if not root:
                return
            
            res.append(root.val)
            dfs(root.left)
            dfs(root.right)
            
        dfs(root)
        return res

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        def dfs(root):
            if not root:
                return
            dfs(root.left)
            res.append(root.val)
            dfs(root.right)
        dfs(root)
        return res

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []

        def dfs(root):
            if not root:
                return
            
            dfs(root.left)
            dfs(root.right)
            res.append(root.val)

        dfs(root)
        return res

前中后序遍历的迭代写法：

深搜迭代就是模拟堆栈。

前序：

首先root进栈，每次循环弹出栈顶元素，记录值并将左右子树进栈，这里要注意先压右子树再压左子树。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        if not root:
            return []
        stack = [root]

        while stack:
            cur = stack.pop()
            res.append(cur.val)
            if cur.right:
                stack.append(cur.right)
            if cur.left:
                stack.append(cur.left)
        
        return res

中序：

中序麻烦就麻烦在发现一个节点的时候并不记录他的值，而是从左边返回这个节点的时候再记录值。实际上访问顺序还是一样的都是深搜，代码中需要显式表示“从左边返回”即可。

自己先写一版：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        def isNext(pre, cur):
            if pre and cur.left:
                cur = cur.left
                while cur.right:
                    cur = cur.right
                if cur == pre:
                    return True
            return False

        res = []
        if not root:
            return []
        stack = [root]
        pre = None
        while stack:
            cur = stack[-1]
            if isNext(pre, cur):
                res.append(cur.val)
                pre = stack.pop()
            else:
                while cur.left:
                    stack.append(cur.left)
                    cur = cur.left
                res.append(cur.val)
                pre = stack.pop()
            if cur.right:
                stack.append(cur.right)

        return res

这份代码能AC, 但是实在是臃肿。看一下题解解法，优化一下自己的思路。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        stack = []
        cur = root

        if not root:
            return []
        
        while cur or stack:
            while cur:
                stack.append(cur)
                cur = cur.left
            cur = stack.pop()
            res.append(cur.val)
            cur = cur.right
        return res

优化：题解方法中，只使用一个cur指针即可。每个循环开始时，一直找左子树的最左边的空，这时候回头查看栈顶，栈顶元素就是中。随后把cur指向中的右，如果右是个空，则直接取栈顶，也就是模拟返回，否则在右子树中继续找左。

这个模拟更加简洁，有点难想到。

后序：

直接反转有点trivial，这里仿照中序硬写一版。

class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        if not root:
            return []
        stack = []
        cur = root
        pre = None

        while cur or stack:
            while cur:
                stack.append(cur)
                cur = cur.left

            top = stack[-1]

            if top.right and top.right != pre:
                cur = top.right
            else:
                stack.pop()
                res.append(top.val)
                pre = top
            
        return res

统一迭代：

标记法，分为空标记和布尔标记。

空标记：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        if not root:
            return []
        stack = [root]

        while stack:
            node = stack[-1]
            if node != None:
                stack.pop()
                if node.right:
                    stack.append(node.right)
                stack.append(node)
                stack.append(None)
                if node.left:
                    stack.append(node.left)

            else:
                stack.pop()
                res.append(stack.pop().val)

        return res

布尔标记：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        if not root:
            return []
        stack = [(root, 0)]

        while stack:
            node = stack[-1]
            if node[1]:
                stack.pop()
                res.append(node[0].val)
            else:
                stack.pop()

                if node[0].right:
                    stack.append((node[0].right, 0))
                stack.append((node[0], 1))
                if node[0].left:
                    stack.append((node[0].left, 0))
        return res

广搜

很基础，使用队列。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        from collections import deque
        res = []
        if not root:
            return []
        que = deque([root])

        while que:
            level = []
            for i in range(len(que)):
                cur = que.popleft()
                level.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            res.append(level)
        return res