python 二叉树总结(一)

最新推荐文章于 2024-09-03 10:31:55 发布
最新推荐文章于 2024-09-03 10:31:55 发布
阅读量2.3k 收藏 9
点赞数 4
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45548695/article/details/124051142
版权

python 二叉树总结（一）

二叉树前中后遍历（深度优先）

前序遍历

# 递归法
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        def Traversal(root):
            if root == None:
                return
            res.append(root.val)
            Traversal(root.left)
            Traversal(root.right)
        Traversal(root)
        return res

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

后序遍历

# 递归法
class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        def Traversal(root):
            if root == None:
                return
            Traversal(root.left)
            Traversal(root.right)
            res.append(root.val)
        Traversal(root)
        return res

# 迭代法
class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if root == None:
            return []
        stack = [root]
        res = []
        while stack:
            node = stack.pop()
            res.append(node.val)
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
        return res[::-1]

中序遍历

# 递归法
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        def Traversal(root):
            if root == None:
                return
            Traversal(root.left)
            res.append(root.val)
            Traversal(root.right)
        Traversal(root)
        return  res

# 迭代法
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        stack = []  # 不能提前将root结点加入stack中
        res = []
        cur = root
        while cur or stack:
            # 先迭代访问最底层的左子树结点
            if cur:
                stack.append(cur)
                cur = cur.left
            # 到达最左结点后处理栈顶结点 
            else:
                cur = stack.pop()
                res.append(cur.val)
                # 取栈顶元素右结点
                cur = cur.right
        return res

前中后迭代统一遍历法：

class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        stack = []
        res = []
        if root:
            stack.append(root)
        while stack:
            node = stack.pop()
            if node != None:
                stack.append(node)
                stack.append(None)
                
                if node.right:
                    stack.append(node.right)
                
                if node.left:
                    stack.append(node.left)
            else:
                node = stack.pop()
                res.append(node.val)
        return res

二叉树层序遍历（广度优先）

102.二叉树的层序遍历

迭代法：
class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        res = []
        if root == None:
            return res
        
        from collections import deque
        que = deque([root])

        while que:
            size = len(que)
            result = []
            for _ in range(size):
                node = que.popleft()
                result.append(node.val)

                if node.left:
                    que.append(node.left)
                
                if node.right:
                    que.append(node.right)
            res.append(result)

        return res

递归法：
class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        res = []
        def helper(node, depth):
            if node == None:
                return []
            if len(res) == depth:res.append([])
            res[depth].append(node.val)
            if node.left:
                helper(node.left, depth + 1)
            if node.right:
                helper(node.right, depth + 1)
        helper(root, 0)
        return res

107.二叉树的层次遍历II
从下至上就是把result倒过来

class Solution:
    def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
        if root == None:
            return []
        res = []

        from collections import deque
        que = deque([root])
        
        while que:
            size = len(que)
            result = []
            for _ in range(size):
                node = que.popleft()
                result.append(node.val)

                if node.left:
                    que.append(node.left)

                if node.right:
                    que.append(node.right)
            res.append(result)
        return res[::-1]

199.二叉树的右视图
res 里 保存每个result 的最后一位就行

class Solution:
    def rightSideView(self, root: TreeNode) -> List[int]:
        res = []
        if root == None:
            return res
        
        from collections import deque
        que = deque([root])
        
        while que:
            size = len(que)
            result = []
            for _ in range(size):
                node = que.popleft()
                result.append(node.val)

                if node.left:
                    que.append(node.left)

                if node.right:
                    que.append(node.right)
            
            res.append(result[-1])
        
        return res

637.二叉树的层平均值

class Solution:
    def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        res = []
        if root == None:
            return res
        
        from collections import deque
        que = deque([root])
        
        while que:
            size = len(que)
            result = []
            for _ in range(size):
                node = que.popleft()
                result.append(node.val)

                if node.left:
                    que.append(node.left)

                if node.right:
                    que.append(node.right)
            
            res.append(sum(result) / len(result))
        
        return res

429.N叉树的层序遍历

class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        res = []
        if root == None:
            return res
        
        from collections import deque
        que = deque([root])

        while que:
            size = len(que)
            result = []
            for _ in range(size):
                node = que.popleft()
                result.append(node.val)

                if node.children:
                    que.extend(node.children)

            res.append(result)

        return res

515.在每个树行中找最大值

class Solution:
    def largestValues(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        if root == None:
            return res
        
        from collections import deque
        que = deque([root])
        
        while que:
            size = len(que)
            result = []
            for _ in range(size):
                node = que.popleft()
                result.append(node.val)

                if node.left:
                    que.append(node.left)

                if node.right:
                    que.append(node.right)
            
            res.append(max(result))
        
        return res

116.填充每个节点的下一个右侧节点指针

层序遍历法:
class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        if root == None:
            return None
        
        from collections import deque
        que = deque([root])
        
        while que:
            n = len(que)
            for i in range(n):
                node = que.popleft()

                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
                if i == n-1:
                    break
                    
                node.next = que[0]
        return root

链表：
class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        if not root:
            return None
        head = root
        while head:
            cur = head
            while cur:
                if cur.left: cur.left.next = cur.right
                if cur.right and cur.next: cur.right.next = cur.next.left
                cur = cur.next
            head = head.left
        return root

117.填充每个节点的下一个右侧节点指针II

层序遍历：
class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if not root:
            return None
        
        from collections import deque
        que = deque([root])
        
        while que:
            size = len(que)
            for i in range(size):
                node = que.popleft()

                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
                if i == size - 1:
                    break
                
                node.next = que[0]
        return root

104.二叉树的最大深度

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        res = []

        from collections import deque
        que = deque([root])
        
        while que:
            n = len(que)
            result = []
            for _ in range(n):
                node = que.popleft()
                result.append(node.val)

                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
                
            res.append(result)
        
        return len(res)

111.二叉树的最小深度

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
            
        from collections import deque
        que = deque([(root, 1)])
        
        while que:
            size = len(que)
            for _ in range(size):
                node, depth = que.popleft()
                
                if node.left == None and node.right == None:
                    return depth
                
                if node.left:
                    que.append((node.left, depth + 1))
                if node.right:
                    que.append((node.right, depth + 1))
        
        return que[0][1]

翻转二叉树

层序遍历：
class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None

        from collections import deque
        que = deque([root])

        while que:
            size = len(que)
            for _ in range(size):
                node = que.popleft()
                node.left, node.right = node.right, node.left

                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
                
        return root

递归(前序)：
class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        def inver(node):
            if not node:
                return 
            node.left, node.right = node.right, node.left
            inver(node.left)
            inver(node.right)
        inver(root)
        return root


迭代（前序）:
class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None
        stack = [root]
        while stack:
            node = stack.pop()

            node.left, node.right = node.right, node.left
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
        return root
Travislgd
关注
Python数据结构——树
Echo_Wish的博客
10-27 1191
树是一种重要的数据结构，用于组织和管理数据，具有广泛的应用。在Python中，你可以使用自定义类来实现二叉树、二叉搜索树，也可以使用第三方库来创建平衡二叉树。了解树数据结构及其应用场景将有助于你更好地解决各种编程问题，从算法设计到数据库管理，都需要树来组织和管理数据。无论是在数据结构设计、算法实现、数据库管理还是编程竞赛中，树都是一个非常有用的工具。
树Tree【代码笔记】
PrototypeOne的博客
12-29 1057
树是n（n>=0）个结点的有限集。当n = 0时，称为空树。显然，树的定义是递归的，即在树的定义中又用到了自身，树是一种递归的数据结构。因此n个结点的树中有n-1条边。
二叉树的Python实现
最新发布
龙晨天的博客
09-03 1183
二叉树（Binary Tree）是n（n≥0）个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。图6-5-2就是一棵二叉树。而图6-2-1的树，因为D结点有三个子树，所以它不是二叉树。
Python 数据结构 tree 树
热门推荐
xuelians的博客
04-19 3万+
树结构 tree 为常用的数据结构，本文是用python实现的树结构的基本节点类TreeNode，并实现相关字节点的增，删，查找等操作。
python中treenode_Python与数据结构[3] -> 树/Tree[1] -> 表达式树和查找树的 Python 实现...
weixin_39630771的博客
12-08 2380
表达式树和查找树的 Python 实现目录1二叉表达式树表达式树是二叉树的一种应用，其树叶是常数或变量，而节点为操作符，构建表达式树的过程与后缀表达式的计算类似，只不过在遇到运算符时不是进行计算，而是将树节点赋值为运算符，并将节点的左右叶子指向两个变量构成一个基本的二叉树后再压入栈中。Expression Tree:*|___________| |+ *|_...
python实现树结构的json文件_zTree -- jQuery 树插件 构造treeNode JSON 数据对象
weixin_39887748的博客
02-10 311
前言zTree 是一个依靠 jQuery 实现的多功能 “树插件”。上回说到，在大型项目中，往往需要不同的用户看到不同的目录，不同的地区显示不同的目录等等，面对这些庞大的数据，需要生成不同结构的树目录，你不能一个一个定义这些配置来满足那么多数据需求，这就需要异步加载子节点的的父节点，通过构造treeNode的 JSON 数据对象方法来实现，如果你不嫌我啰嗦，接下来会给大家讲述这个方法。settin...
python中treenode_python二叉树遍历的实现方法
weixin_39871378的博客
12-08 3862
#!/usr/bin/python# -*- coding: utf-8 -*-class TreeNode(object):def __init__(self,data=0,left=0,right=0):self.data = dataself.left = leftself.right = rightclass BTree(object):def __init__(self,root=0):...
Python二叉树的遍历操作示例【前序遍历,中序遍历,后序遍历,层序遍历】
09-19
### Python二叉树的遍历操作详解 #### 一、引言 在计算机科学领域，二叉树是一种常见的数据结构，广泛应用于各种算法设计中。本文将深入探讨Python中的二叉树及其遍历方法，包括前序遍历、中序遍历、后序遍历以及...
Python二叉树的镜像转换实现方法示例
09-19
总结来说，Python中实现二叉树的镜像转换主要有两种方法：一种是创建新的镜像二叉树，另一种是直接修改原二叉树。实际应用中，直接修改原二叉树的“就地”转换方法更为高效，因为它避免了额外的空间开销。对于二叉树...
python 二叉树遍历汇总
Yangcp_的博客
08-28 957
python二叉树遍历
Python实现二叉树的常见遍历操作总结【7种方法】
01-20
本文实例讲述了Python实现二叉树的常见遍历操作。分享给大家供大家参考，具体如下： 二叉树的定义： class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None 二叉树的前序...
python tree
09-22
简单的利用递归实现tree的画法，对于初学者，可以从网上下载对应的库，仔细研究里面的函数的用法和用途，。。。
python实现二叉树
cjzcc1996的博客
07-04 5650
首先我们先介绍数的概念。结点：使用树结构存储的每一个数据元素都被称为“结点”。例如，图 1（A）中，数据元素 A 就是一个结点；父结点（双亲结点）、子结点和兄弟结点：对于图 1（A）中的结点 A、B、C、D 来说，A 是 B、C、D 结点的父结点（也称为“双亲结点”），而 B、C、D 都是 A 结点的子结点（也称“孩子结点”）。对于 B、C、D 来说，它们都有相同的父结点，所以它们互为兄弟结点。树根结点（简称“根结点”）：每一个非空树都有且只有一个被称为根的结点。图 1（A）中，结点A就是整棵树的根结点。叶
python数据结构-树(草稿)
You will~My hand
01-14 711
❏ 除根节点外，其他每个节点都与其唯一的父节点相连； ❏ 从根节点到其他每个节点都有且仅有一条路径； ❏ 如果每个节点最多有两个子节点，我们就称这样的树为二叉树。 定义二：(递归定义) 一棵树要么为空，要么由一个根节点和零棵或多棵子树构成，子树本身也是一棵树。每棵子树的根节点通过一条边连到父树的根节点。 实现 以下函数创建并操作二叉树 实现树的关键在于选择一个好的内部存储技巧。Python提供两种有意思的方式，我们在选择前会仔细了解
Python数据结构与算法之树
qq_63215420的博客
01-05 1585
树是一种非常重要的非线性结构，它在计算机领域的应用十分广泛，如在编译程序或数据库程序中。树形结构具有分支性（分支性是由于一个或多个或多个结点存在两个或两个以上直接后继节点）和层次性（层次性是由分支产生并呈现出来的）两大特点。
树--python
Sinde1992的博客
09-05 421
# coding=utf-8 class node(object): def __init__(self,data=None,left=None,right=None): self.data=data self.left=left self.right=right #深度 def depth(tree): i
Python高级数据结构——树（Tree）
Echo_Wish的博客
11-29 3373
在本文中，我们将深入讲解Python中的树，包括树的基本概念、表示方法、常见类型、遍历算法以及实际应用。二叉搜索树（Binary Search Tree，BST）是一种有序的二叉树，对于每个节点，其左子树的所有节点值都小于该节点值，右子树的所有节点值都大于该节点值。树的遍历是按照一定规则依次访问树的所有节点，主要有前序遍历、中序遍历和后序遍历。使用字典表示树的层次结构，每个节点的键是节点的数据，值是其子节点的字典。使用类表示树的节点，每个节点包含数据、左子节点和右子节点。树是由节点和边组成的层次结构。
python之树的实现
LZH_12345的博客
03-31 7176
一、前言树的术语是生物学、家谱学和几何学术语的一个特殊混合体。它很好的表示了层级结构，它的两个主要特征：每个项都有多个子节点。除了叫做根（树最顶端的节点）的特殊项，所有其他的项都只有一个父节点。普通的树和二叉树的递归定义：普通的树------普通的树要么为空，要么包含一个有限的节点的集合T。有一个和所有其他节点不同的节点r，称为根，此外，集合T-{r}被划分为不相连的子集，每个子集都是一个普通的树...
python 之树序列化和反序列化
weixin_38825407的博客
02-19 716
class TreeNode(object): def __init__(self, val): self.val = val self.left = None self.right = None class Solution(object): def creatTree(self): t = TreeNode(...
python 二叉树
09-12
在Python中，二叉树可以通过使用节点类和引用来表示。每个节点类可以有一个值，一个指向左子树的引用和一个指向右子树的引用。通过这种方式，我们可以构建一个完整的二叉树数据结构。 首先，我们需要定义一个节点类，如以下示例所示： ```python class Node: def __init__(self, value): self.value = value self.left = None self.right = None ``` 然后，我们可以使用这个节点类来创建二叉树。例如，如果我们要创建一个简单的二叉树，可以按照以下步骤进行： 1. 创建根节点： ```python root = Node(1) ``` 2. 创建左子节点和右子节点，并将它们连接到根节点： ```python root.left = Node(2) root.right = Node(3) ``` 3. 继续为每个子节点添加左子节点和右子节点，以构建完整的二叉树。 可以看出，这是一个基本的二叉树的构建过程。在实际应用中，我们可以根据具体的需求对二叉树进行扩展和操作。例如，我们可以实现插入节点、删除节点、搜索节点等功能。 总结起来，通过使用节点类和引用，我们可以在Python中表示和操作二叉树。这种表示方法可以适用于各种二叉树的应用场景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值