python中树的构建（采用层序遍历的方式构建）和遍历（层、前、中、后）

已于 2023-04-06 12:37:55 修改
阅读量329 收藏 1
点赞数
文章标签： python 开发语言
于 2023-04-05 19:56:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Luxmlb/article/details/129974708
版权

1.基本的构造，以及集中遍历的实现

#encoding=utf-8
from collections import deque
#定义一个节点类
class Node:
    def __init__(self,elem=-1,lchild=None,rchild=None):
        self.elem=elem
        self.lchild=lchild
        self.rchild=rchild

class Tree:
    def __init__(self,root=None):
        self.root=root

    #利用层序遍历向树中添加元素
    def add(self,elem):
        node=Node(elem)
        if self.root==None:
            self.root=node
        else:
            queue=deque()
            queue.append(self.root)
            while queue:
                cur_node=queue.popleft()
                if cur_node.lchild is None:
                    cur_node.lchild=node
                    #return 是结束查找，这个很重要（函数返回）
                    return
                else:
                    queue.append(cur_node.lchild)
                if cur_node.rchild is None:
                    cur_node.rchild=node
                    return
                else:
                    queue.append(cur_node.rchild)
    #层序遍历
    def breadth_travl(self):
        if self.root==None:
            return
        else:
            queue=deque()
            queue.append(self.root)
            while queue:
                cur_node=queue.popleft()
                print(cur_node.elem,end=" ")
                if cur_node.lchild is not None:
                    queue.append(cur_node.lchild)
                if cur_node.rchild is not None:
                    queue.append(cur_node.rchild)

    #前序遍历
    #关于node参数：因为是递归遍历，所以一定存在子树的根，也就是需要一个node参数来代表子树的根
    def pre_oder(self,node):
    #递归结束的条件是：叶子节点的左和右子树是none那么它在执行self.pre_oder(node.lchild)就改返回
        if node is None:
            return
        print(node.elem,end=" ")
        self.pre_oder(node.lchild)
        self.pre_oder(node.rchild)
    #中序遍历
    def in_oder(self,node):
        if node==None:
            return
        self.in_oder(node.lchild)
        print(node.elem,end=" ")
        self.in_oder(node.rchild)

    #后序遍历
    def post_oder(self,node):
        if node==None:
            return
        self.post_oder(node.lchild)
        self.pre_oder(node.rchild)
        print(node.elem,end=" ")

if __name__=="__main__":
    tree=Tree()
    for i in range(1,7):
        tree.add(i)
    tree.breadth_travl()
    print()
    tree.pre_oder(tree.root)
    print()
    tree.in_oder(tree.root)
    print()
    tree.post_oder(tree.root)

2.已知前序和中序，求后序

#encoding=utf-8
from collections import deque
#定义一个节点类
class Node:
    def __init__(self,elem=-1,lchild=None,rchild=None):
        self.elem=elem
        self.lchild=lchild
        self.rchild=rchild

class Tree:
    def __init__(self,root=None):
        self.root=root

    #利用层序遍历向树中添加元素
    def add(self,elem):
        node=Node(elem)
        if self.root==None:
            self.root=node
        else:
            queue=deque()
            queue.append(self.root)
            while queue:
                cur_node=queue.popleft()
                if cur_node.lchild is None:
                    cur_node.lchild=node
                    #return 是结束查找，这个很重要（函数返回）
                    return
                else:
                    queue.append(cur_node.lchild)
                if cur_node.rchild is None:
                    cur_node.rchild=node
                    return
                else:
                    queue.append(cur_node.rchild)
    #层序遍历
    def breadth_travl(self):
        if self.root==None:
            return
        else:
            queue=deque()
            queue.append(self.root)
            while queue:
                cur_node=queue.popleft()
                print(cur_node.elem,end=" ")
                if cur_node.lchild is not None:
                    queue.append(cur_node.lchild)
                if cur_node.rchild is not None:
                    queue.append(cur_node.rchild)

    #前序遍历
    #关于node参数：因为是递归遍历，所以一定存在子树的根，也就是需要一个node参数来代表子树的根
    def pre_oder(self,node):
    #递归结束的条件是：叶子节点的左和右子树是none那么它在执行self.pre_oder(node.lchild)就改返回
        if node is None:
            return
        print(node.elem,end=" ")
        self.pre_oder(node.lchild)
        self.pre_oder(node.rchild)
    #中序遍历
    def in_oder(self,node):
        if node==None:
            return
        self.in_oder(node.lchild)
        print(node.elem,end=" ")
        self.in_oder(node.rchild)

    #后序遍历
    def post_oder(self,node):
        if node==None:
            return
        self.post_oder(node.lchild)
        self.pre_oder(node.rchild)
        print(node.elem,end=" ")

    def re_construct_tree(self,pre,mid):
        if len(pre)==0:
            return None
        root=Node(pre[0])
        mid_index=mid.index(pre[0])
        root.lchild=self.re_construct_tree(pre[1:mid_index+1],mid[0:mid_index])
        root.rchild=self.re_construct_tree(pre[mid_index+1:],mid[mid_index+1:])
        return root



if __name__=="__main__":
    pre = [1,2,4,5,3,6]
    tin = [4,2,5,1,6,3]
    tree=Tree()
    root=tree.re_construct_tree(pre,tin)
    tree.post_oder(root)

3.已知后序和中序求前序

#encoding=utf-8
from collections import deque
#定义一个节点类
class Node:
    def __init__(self,elem=-1,lchild=None,rchild=None):
        self.elem=elem
        self.lchild=lchild
        self.rchild=rchild

class Tree:
    def __init__(self,root=None):
        self.root=root

    #利用层序遍历向树中添加元素
    def add(self,elem):
        node=Node(elem)
        if self.root==None:
            self.root=node
        else:
            queue=deque()
            queue.append(self.root)
            while queue:
                cur_node=queue.popleft()
                if cur_node.lchild is None:
                    cur_node.lchild=node
                    #return 是结束查找，这个很重要（函数返回）
                    return
                else:
                    queue.append(cur_node.lchild)
                if cur_node.rchild is None:
                    cur_node.rchild=node
                    return
                else:
                    queue.append(cur_node.rchild)
    #层序遍历
    def breadth_travl(self):
        if self.root==None:
            return
        else:
            queue=deque()
            queue.append(self.root)
            while queue:
                cur_node=queue.popleft()
                print(cur_node.elem,end=" ")
                if cur_node.lchild is not None:
                    queue.append(cur_node.lchild)
                if cur_node.rchild is not None:
                    queue.append(cur_node.rchild)

    #前序遍历
    #关于node参数：因为是递归遍历，所以一定存在子树的根，也就是需要一个node参数来代表子树的根
    def pre_oder(self,node):
    #递归结束的条件是：叶子节点的左和右子树是none那么它在执行self.pre_oder(node.lchild)就改返回
        if node is None:
            return
        print(node.elem,end=" ")
        self.pre_oder(node.lchild)
        self.pre_oder(node.rchild)
    #中序遍历
    def in_oder(self,node):
        if node==None:
            return
        self.in_oder(node.lchild)
        print(node.elem,end=" ")
        self.in_oder(node.rchild)

    #后序遍历
    def post_oder(self,node):
        if node==None:
            return
        self.post_oder(node.lchild)
        self.pre_oder(node.rchild)
        print(node.elem,end=" ")
    def re_construct_tree(self,post,mid):
        if len(post)==0:
            return None
        root=Node(post[-1])
        mid_index=mid.index(post[-1])
        root.lchild=self.re_construct_tree(post[:mid_index],mid[0:mid_index])
        root.rchild=self.re_construct_tree(post[mid_index:-1],mid[mid_index+1:])
        return root
if __name__=="__main__":
    post = [4, 5, 2, 3, 6, 1]
    tin = [4, 2, 5, 1, 6, 3]
    tree=Tree()
    root=tree.re_construct_tree(post,tin)
    tree.pre_oder(root)

 

 

 下面的代码中整合了上面的代码以及开了几个list（不能开deque因为deque不支持切片操作）来存储每次遍历后的值，方便后面的使用，以后找时间优化注释

from collections import deque
#用来保存层序的队列
breadth_order_list=[]

#用来保存前序的队列
former_order_list=[]

#用来保存中序的队列
mid_order_list=[]

#用来保存后序的队列
post_order_list=[]
class Node():
    def __init__(self,elem=-1,lchild=None,rchild=None):
        self.elem=elem
        self.lchild=lchild
        self.rchild=rchild
class Tree():
    def __init__(self,root=None):
        self.root=root

    def add(self, elem):
        node = Node(elem)
        if self.root == None:
            self.root = node
        else:
            queue1 = deque()
            queue1.append(self.root)
            while queue1:
                cur_node = queue1.popleft()
                if cur_node.lchild is None:
                    cur_node.lchild = node
                    return
                else:
                    queue1.append(cur_node.lchild)
                if cur_node.rchild is None:
                    cur_node.rchild = node
                    return
                else:
                    queue1.append(cur_node.rchild)

    #层序
    def breadth_oder(self,breth_list):
        if self.root==None:
            return
        queue=deque()
        queue.append(self.root)
        while queue:
            cur_node=queue.popleft()
            breth_list.append(cur_node.elem)
            print(cur_node.elem,end=" ")
            if cur_node.lchild is not None:
                queue.append(cur_node.lchild)
            if cur_node.rchild is not None:
                queue.append(cur_node.rchild)

    #前序
    def former_order(self,node,former_list):
        if node==None:
            return
        else:
            former_list.append(node.elem)
            print(node.elem,end=" ")
            if node.lchild is not None:
                self.former_order(node.lchild,former_list)
            if node.rchild is not None:
                self.former_order(node.rchild,former_list)

    #中序
    def mid_order(self,node,mid_list):
        if node is None:
            return
        else:
            self.mid_order(node.lchild,mid_list)
            mid_list.append(node.elem)
            print(node.elem,end=" ")
            self.mid_order(node.rchild,mid_list)
    #后序
    def post_order(self,node,post_list):
        if node is None:
            return
        else:
            self.post_order(node.lchild,post_list)
            self.post_order(node.rchild,post_list)
            post_list.append(node.elem)
            print(node.elem,end=" ")
    #1.已知前序，中序求后序
    def tree_transform_1(self,pre,mid):
        if len(pre)==0:
            return
        root=Node(pre[0])
        mid_index=mid.index(pre[0])
        root.lchild=self.tree_transform_1(pre[1:mid_index+1],mid[0:mid_index])
        root.rchild=self.tree_transform_1(pre[mid_index+1:],mid[mid_index+1:])
        return root
    #2.已知后序，中序，求前序
    def tree_transform_2(self,post,mid):
        if len(post)==0:
            return
        root=Node(post[-1])
        mid_index=mid.index(post[-1])
        root.lchild=self.tree_transform_2(post[:mid_index],mid[0:mid_index])
        root.rchild=self.tree_transform_2(post[mid_index:-1],mid[mid_index+1:])
        return root

if __name__=="__main__":
    tree=Tree()
    for i in range(1,6):
        tree.add(i)
    tree.breadth_oder(breadth_order_list)
    print()
    tree.former_order(tree.root,former_order_list)
    print()
    tree.mid_order(tree.root,mid_order_list)
    print()
    tree.post_order(tree.root,post_order_list)
    print()
    #1.已知前序，中序，求后序
    main_post_order_list=[]
    root1=tree.tree_transform_1(former_order_list,mid_order_list)
    tree.post_order(root1,main_post_order_list)
    print()
    #2.已知后序，中序，求前序
    main_former_order_list=[]
    root2=tree.tree_transform_2(post_order_list,mid_order_list)
    tree.former_order(root2,main_former_order_list)

 

Luxmlb
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
树形结构（Python）
DSBWB的博客
10-23 3414
树（python）
神奇！教你如何用Python来画树
CSDN_224022的博客
06-09 1163
古人有诗云“庭中有奇树，绿叶发华滋”，树之美，或婀娜、或繁茂、或苍劲、或青翠。python-turtle笔下的树更是别有一番风味。
数据结构与算法 —— 树的基本操作以及实现（python实现）
‘’
05-05 1828
树是由节点和边组成的非线性数据结构。其结构可以用来表示层次关系，例如文件系统的目录结构、公司的组织架构等。本文用python来实现一颗通用树，可以用于构建任何类型的树，如二叉树、多叉树等。定义了一个类Node，并使用Generic[T]表示它是一个泛型类，类型参数为T。在类中定义了四个属性，分别是_value_parent_children和。其中，_value用于存储节点的值，_parent用于存储节点的父节点，_children用于存储节点的子节点列表，用于存储节点的子树大小。__init__
python 层序遍历建树
ChangNianYiEr的博客
03-16 1563
class BinaryTree: '''定义一个树''' def __init__(self): self.val = None self.left = None self.right = None '''前序遍历建树''' def bulidTree(self,arrs): if not len(arrs): return None if arrs[0] =..
Python语言建立二叉树的几种方式（适用于需要建树的场景）
化身孤岛的鲸o的博客
03-25 5476
Python语言建立二叉树的几种方式（适用于需要建树的场景）
Python二叉树的遍历操作示例【前序遍历,中序遍历,后序遍历,层序遍历】
09-19
主要介绍了Python二叉树的遍历操作,结合实例形式分析了Python针对二叉树的前序遍历,中序遍历,后序遍历,层序遍历等相关操作实现技巧,需要的朋友可以参考下
Python解析树及树的遍历
09-21
本篇是给大家介绍的Python实现解析树以及实现二叉树的三种遍历，先序遍历，中序遍历，后序遍历的例子，非常的详细，有需要的小伙伴可以参考下。
python实现二叉树前中后序列遍历
10-08
python实现二叉树前中后序列遍历 本篇功能：python实现将前序序列构建二叉树。输出二叉树的中序和后续排列。 二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有深度...
python实现树的深度优先遍历与广度优先遍历详解
09-18
主要介绍了python实现树的深度优先遍历与广度优先遍历,详细分析了树的深度优先遍历与广度优先遍历原理及Python相关实现技巧,需要的朋友可以参考下
Python高级数据结构——树（Tree）
最新发布
Echo_Wish的博客
11-29 2502
在本文中，我们将深入讲解Python中的树，包括树的基本概念、表示方法、常见类型、遍历算法以及实际应用。二叉搜索树（Binary Search Tree，BST）是一种有序的二叉树，对于每个节点，其左子树的所有节点值都小于该节点值，右子树的所有节点值都大于该节点值。树的遍历是按照一定规则依次访问树的所有节点，主要有前序遍历、中序遍历和后序遍历。使用字典表示树的层次结构，每个节点的键是节点的数据，值是其子节点的字典。使用类表示树的节点，每个节点包含数据、左子节点和右子节点。树是由节点和边组成的层次结构。
python数据结构之树
柳小葱的博客
01-02 3106
☀️上一节我们学习了数据结构里面的各种排序算法，今天，我们接着学习数据结构中又一重要的结构：树，对往期内容感兴趣的小伙伴可以参考下面内容????: python数据类型: python数据结构之数据类型. python的输入输出: python数据结构之输入输出、控制和异常. python数据结构之面向对象: python数据结构之面向对象. python数据结构之算法分析: python数据结构之算法分析. python数据结构之栈、队列和双端队列: python数据结构之栈、队列和双端队列. pyth
Python实现树的遍历以及恢复
qq_45813977的博客
08-01 1051
本文是关于用python实现对树的递归遍历，并用中序遍历分别结合前序和后序遍历恢复一颗树。
Python实现树结构的两种方式
Chauncy的博客
03-12 6780
实现树结构的经典方法是：嵌套列表法 这里把我踩的坑记录一下 ''' 使用嵌套列表法实现树的基本功能 ''' def BinaryTree(r): return [r, [], []] def insertLeft(root, newBranch): t = root.pop(1) if len(t) > 1: # 如果左子树非空，就把原来根节点上的左子树作为新的根的左节点的左子树 root.insert(1, [newBranch, t, [
python生成树形结构 菜单 tree
xiao_ma的博客
03-17 2017
首先需要设计表结构，包含父子关联关系，例如 class Menu(models.Model): """ 权限 """ title = models.CharField(max_length=128, unique=True, verbose_name="标题") name = models.CharField(max_length=128, unique=True, verbose_name="编码") path = models.CharField(max_
【Python】python实现树结构
ninnyyan的博客
07-11 8465
树是我们常见的一种一对多的数据结构。 最近为了处理一些事情，写了一颗三层的树。每层的子节点数目均不确定，动态添加。 为了方便管理，写成了嵌套树。 “` 第一层树，创建树时必须指定根结点，不支持创建空树 整颗树存储在tree_dict中，key为root，value为children_dict children_dict中存储所有的子节点，个数不确定，动态添加 class ...
利用Python创建二叉树。
acarsar的博客
02-24 8199
记录下用Python如何创建一个二叉树 1.定义一个节点类，为每一个节点都赋予左右孩子的属性，然后后续才能往下添加节点 class Node(object): def __init__(self, number): self.number = number self.left = None self.right = None 2.建立二叉树...
python树构建_如何在Python中创建树结构？
weixin_31955465的博客
02-04 1688
我正在尝试做一个人工智能，它玩的游戏看起来很像跳棋，逻辑基本上是一样的。但是我没有用蒙特卡罗的方法来实现树的结构。如果我没有错，我的树的根应该是初始状态或板，节点应该是所有可能的播放。我知道我必须创建一个函数来计算每个节点的权重并选择可能的最佳播放。我的问题是，如前所述，我不知道如何在python中实现所述树。在到目前为止，我有我的董事会和两个功能，返回您可以采取的合法行动的列表。电路板是用一个1...
python - python实现tree命令
qq_48391148的博客
02-27 3315
tree 命令 ： 显示目录的树形结构 [root@localhost test]# ls 222 aaaa bbbb cccc.txt [root@localhost test]# tree . ├── 222 ├── aaaa │?? ├── 1111.txt │?? └── qqqq │?? └── fdfd │?? └── jjjj ├── bbbb └── cccc.txt 怎样用python 实现tree命令？ 在python里面有一个 os库 os库有
python构造树_用Python从零开始构造决策树
weixin_39646695的博客
02-21 175
起步本章介绍如何不利用第三方库，仅用python自带的标准库来构造一个决策树。熵的计算公式:对应的 python 代码:条件熵的计算根据计算方法：对应的 python 代码:其中参数 future_list 是某一特征向量组成的列表，result_list 是 label 列表。信息增益根据信息增益的计算方法：对应的python代码:..定义决策树的节点作为树的节点，要有左子树和右子树是必不可少的...
二叉树层序遍历中如何定义节点对象
07-14
在二叉树的层序遍历中，可以使用节点对象来表示每个节点。节点对象可以包含节点的值、左子节点和右子节点等属性。 下面是一个示例的节点对象定义： ```python class TreeNode: def __init__(self, val=0, left=...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值