二叉树，树的遍历

树的遍历

深度优先搜索

前序遍历

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:

        #递归解法
        #result = []
        #def preorder(root):
        #    if not root:
        #        return
        #    result.append(root.val)
        #    preorder(root.left)
        #    preorder(root.right)
        #preorder(root)
        #return result

        #非递归，迭代解法
        stack = []
        result = []
        while stack or root:
            while root:
                result.append(root.val)
                stack.append(root.right)
                root = root.left
            root = stack.pop()
        return result

中序遍历

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:

        # 递归
        # result = []
        # def inorder(root):
        #    if not root:
        #        return
        #    inorder(root.left)
        #    result.append(root.val)
        #    inorder (root.right)
        # inorder(root)
        # return result

        # 迭代
        result = []
        stack = []
        while stack or root:
            while root:
                stack.append(root)
                root = root.left
            root = stack.pop()
            result.append(root.val)
            root = root.right
        return result

后序遍历

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:

        # 递归
        # result = []
        # def postorder(root):
        #    if not root:
        #        return 
        #    postorder(root.left)
        #    postorder(root.right)
        #    result.append(root.val)
        # postorder(root)
        # return result

        # 迭代
        stack = []
        result = []
        while root or stack:
            while root:
                stack.append(root)
                if root.left:
                    root = root.left
                else:
                    root = root.right

            root = stack.pop()
            result.append(root.val)
            if stack and stack[-1].left == root:
                root = stack[-1].right
            else:
                root = None
        return result

层序遍历

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:

        def level_num(root):
            if not root:
                return 0
            else:
                return max(1 + level_num(root.left), 1 + level_num(root.right))

        queue = []
        result = [[] for _ in range(level_num(root))]
        queue.append((root, 0))

        while root or queue:
            root, level = queue.pop(0)

            if root:
                result[level].append(root.val)
                queue.append((root.left, level + 1))
                queue.append((root.right, level + 1))

        return result

DFS 深度搜索-从下向上（分治法）/前序中序后序都可采用

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        
        if root is None:
            return []
        
        left_result = self.preorderTraversal(root.left)
        right_result = self.preorderTraversal(root.right)
        
        return [root.val] + left_result + right_result

分治法应用
先分别处理局部，再合并结果
适用场景

快速排序
归并排序
二叉树相关问题

分治法模板

递归返回条件
分段处理
合并结果