python 二叉树总结(一)

最新推荐文章于 2024-05-10 09:48:37 发布
最新推荐文章于 2024-05-10 09:48:37 发布
阅读量2.2k 收藏 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
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python中treenode_Python与数据结构[3] -> 树/Tree[1] -> 表达式树和查找树的 Python 实现...
weixin_39630771的博客
12-08 2356
表达式树和查找树的 Python 实现目录1二叉表达式树表达式树是二叉树的一种应用，其树叶是常数或变量，而节点为操作符，构建表达式树的过程与后缀表达式的计算类似，只不过在遇到运算符时不是进行计算，而是将树节点赋值为运算符，并将节点的左右叶子指向两个变量构成一个基本的二叉树后再压入栈中。Expression Tree:*|___________| |+ *|_...
Python 数据结构 tree 树
热门推荐
xuelians的博客
04-19 3万+
树结构 tree 为常用的数据结构，本文是用python实现的树结构的基本节点类TreeNode，并实现相关字节点的增，删，查找等操作。
2024年最全Python 实现二叉树前序，中序，后序，层次遍历，把面试官逗笑了
最新发布
m0_60635176的博客
05-10 823
如果你也是看准了Python，想自学Python，在这里为大家准备了丰厚的免费大礼包，带大家一起学习，给大家剖析Python兼职、就业行情前景的这些事儿。
python实现树结构的json文件_zTree -- jQuery 树插件 构造treeNode JSON 数据对象
weixin_39887748的博客
02-10 296
前言zTree 是一个依靠 jQuery 实现的多功能 “树插件”。上回说到，在大型项目中，往往需要不同的用户看到不同的目录，不同的地区显示不同的目录等等，面对这些庞大的数据，需要生成不同结构的树目录，你不能一个一个定义这些配置来满足那么多数据需求，这就需要异步加载子节点的的父节点，通过构造treeNode的 JSON 数据对象方法来实现，如果你不嫌我啰嗦，接下来会给大家讲述这个方法。settin...
Python数据结构——树
Echo_Wish的博客
10-27 1072
树是一种重要的数据结构，用于组织和管理数据，具有广泛的应用。在Python中，你可以使用自定义类来实现二叉树、二叉搜索树，也可以使用第三方库来创建平衡二叉树。了解树数据结构及其应用场景将有助于你更好地解决各种编程问题，从算法设计到数据库管理，都需要树来组织和管理数据。无论是在数据结构设计、算法实现、数据库管理还是编程竞赛中，树都是一个非常有用的工具。
python中treenode_python二叉树遍历的实现方法
weixin_39871378的博客
12-08 3817
#!/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先序遍历二叉树问题
09-21
以下是一个简单的Python代码示例，定义了一个`TreeNode`类来表示二叉树的节点，然后通过`createTree`函数构建了一个具体的二叉树，最后使用`preOrder`函数进行先序遍历： ```python class TreeNode(object): def _...
Python实现二叉树的常见遍历操作总结【7种方法】
09-19
在计算机科学中，二叉树是一种特殊的图结构，其中每个节点最多有两个子节点，通常分为左子节点和右子节点。二叉树遍历是访问二叉树中所有节点的过程，有多种不同的遍历方式，包括前序遍历、中序遍历、后序遍历以及...
Python实现二叉树结构与进行二叉树遍历的方法详解
09-21
总结来说，Python实现二叉树结构主要通过定义类来完成，类中包含插入节点、获取节点等方法。二叉树的遍历则可以通过递归或队列实现，包括前序遍历、中序遍历、后序遍历和层次遍历。理解并掌握这些概念和实现方法对于...
python tree
09-22
简单的利用递归实现tree的画法，对于初学者，可以从网上下载对应的库，仔细研究里面的函数的用法和用途，。。。
Python实现基于二叉树存储结构的堆排序算法示例
09-21
总结来说，这个Python示例展示了如何使用二叉树结构实现堆排序算法。虽然使用二叉树增加了实现的复杂性，但它有助于更好地理解堆排序的内部机制。在实际编程中，数组实现的堆排序更常见，因为它更高效且易于实现。...
python数据结构-树(草稿)
You will~My hand
01-14 662
❏ 除根节点外，其他每个节点都与其唯一的父节点相连； ❏ 从根节点到其他每个节点都有且仅有一条路径； ❏ 如果每个节点最多有两个子节点，我们就称这样的树为二叉树。 定义二：(递归定义) 一棵树要么为空，要么由一个根节点和零棵或多棵子树构成，子树本身也是一棵树。每棵子树的根节点通过一条边连到父树的根节点。 实现 以下函数创建并操作二叉树 实现树的关键在于选择一个好的内部存储技巧。Python提供两种有意思的方式，我们在选择前会仔细了解
Python数据结构与算法之树
qq_63215420的博客
01-05 1463
树是一种非常重要的非线性结构，它在计算机领域的应用十分广泛，如在编译程序或数据库程序中。树形结构具有分支性（分支性是由于一个或多个或多个结点存在两个或两个以上直接后继节点）和层次性（层次性是由分支产生并呈现出来的）两大特点。
树--python
Sinde1992的博客
09-05 396
# 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之树的实现
LZH_12345的博客
03-31 7125
一、前言树的术语是生物学、家谱学和几何学术语的一个特殊混合体。它很好的表示了层级结构，它的两个主要特征：每个项都有多个子节点。除了叫做根（树最顶端的节点）的特殊项，所有其他的项都只有一个父节点。普通的树和二叉树的递归定义：普通的树------普通的树要么为空，要么包含一个有限的节点的集合T。有一个和所有其他节点不同的节点r，称为根，此外，集合T-{r}被划分为不相连的子集，每个子集都是一个普通的树...
python 之树序列化和反序列化
weixin_38825407的博客
02-19 696
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）
迪文的博客
06-24 934
树是一种由节点（node）和边（edges）构成层级关系的结构。如果你了解 linux 文件结构（tree 命令），它的结构也是一棵树。我们快速看下树涉及到的一些概念：二叉树是树结构里面最常用的一种树结构，其实二叉树就是一种简单的树。二叉树的每个节点最多包含两个孩子。从上边的图来看几个二叉树的概念：一棵 size 为 n 的二叉树高度最多可以是 n，最小的高度是 ⌊lgn⌋+1，这里 log 以 2 为底简写为 lgn。一棵二叉树的前序遍历结果 = 根节点 + 左子树的前序遍历结果 + 右子树的前序遍历结果
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、付费专栏及课程。

余额充值