题解：二叉树相关问题及题解（Python）

最新推荐文章于 2024-09-04 14:45:59 发布

v-space

最新推荐文章于 2024-09-04 14:45:59 发布

阅读量1.2k

点赞数

分类专栏：算法&题解文章标签：算法 leetcode 职场和发展

本文链接：https://blog.csdn.net/weixin_42069606/article/details/126740456

版权

算法&题解专栏收录该内容

13 篇文章 0 订阅

订阅专栏

这篇博客详细介绍了如何使用递归和栈两种方法实现二叉树的前序、中序、后序遍历，并提供了层序遍历的实现。递归方法直接且易于理解，而栈方法则通过维护节点顺序实现遍历。这些遍历方法是数据结构和算法学习中的基础内容，对于理解和操作树形结构至关重要。

摘要由CSDN通过智能技术生成

一、前序遍历
1.1 递归

class Solution:
    def preorder(self, root, res):
        if not root:
            return []
        res.append(root.val)
        self.preorder(root.left, res)
        self.preorder(root.right, res)
    def preorderTraversal(self , root: TreeNode) -> List[int]:
        if not root:
            return []
        res = []
        self.preorder(root, res)
        return res

1.2 栈

class Solution:
    def preorderTraversal(self , root: TreeNode) -> List[int]:
        if not root:
            return []
        res = []
        stack = [root]
        while stack:
            node = stack[-1]
            stack = stack[:-1]
            res.append(node.val)
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
        return res

二、中序遍历
2.1 递归

class Solution:
    def inorder(self, root, res):
        if not root:
            return 
        self.inorder(root.left,res)
        res.append(root.val)
        self.inorder(root.right,res)
    def inorderTraversal(self , root: TreeNode) -> List[int]:
        # write code here 
        res = []
        self.inorder(root, res)
        return res

2.2 栈

class Solution:
    def inorderTraversal(self , root: TreeNode) -> List[int]:
        # write code here 
        res = []
        stack = []
        while stack or root:
            while root:
                stack.append(root)
                root = root.left
            root = stack[-1]
            stack = stack[:-1]
            res.append(root.val)
            root = root.right
        return res

三、后序遍历
3.1 递归

class Solution:
    def postorderTraversal(self , root: TreeNode) -> List[int]:
        if not root:
            return []
        res, stack = [],[]
        pre = None
        while root or stack:
            while root:
                stack.append(root)
                root = root.left
            node = stack[-1]
            stack = stack[:-1]
            if not node.right or  node.right is pre:
                res.append(node.val)
                pre = node
            else:
                stack.append( node)
                root  = node.right
        return res

3.2 栈

class Solution:
    def postorderTraversal(self , root: TreeNode) -> List[int]:
        # write code here
        res, stack = [], []
        pre = None
        while root or stack:
            while root:
                stack.append(root)
                root = root.left
            root = stack[-1]
            stack = stack[:-1]
            if not root.right or root.right is pre:
                res.append(root.val)
                pre = root
            else:
                stack.append(root)
                root = root.right
        return res

四、层序遍历
4.1 递归

class Solution:
    res = []
    def traverse(self, root, depth):
        if not root:
            return 
        if len(self.res) < depth:
            row = []
            row.append(root.val)
            self.res.append(row)
        else:
            row = self.res[depth-1]
            row.append(root.val)
        self.traverse(root.left, depth+1)
        self.traverse(root.right, depth+1)
    def levelOrder(self , root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        self.traverse(root,1)
        return self.res

4.2 栈

class Solution:
    def levelOrder(self , root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        res = []
        queue = [root]
        while queue:
            next_layer_node = []
            row = []
            while queue:
                root = queue[0]
                queue = queue[1:]
                row.append(root.val)
                if root.left:
                    next_layer_node.append(root.left)
                if root.right:
                    next_layer_node.append(root.right)
            queue = next_layer_node
            res.append(row)
        return res