Python篇——数据结构与算法（第七部分：树）

于 2023-06-19 14:56:22 发布
阅读量242 收藏
点赞数
分类专栏： Python基础学习——算法 文章标签： python 开发语言 数据结构 算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42120059/article/details/131206995
版权

 

目录

1.树与二叉树

2.树的实例：模拟文件系统

3.二叉树

4.二叉树的遍历

5.二叉搜索树

5.1插入

5.2查询

5.3删除

1.树与二叉树

2.树的实例：模拟文件系统

# 树的实例
class Node:
    def __init__(self, name, type='dir'):
        self.name = name
        self.type = type  # type = "dir" or "file"
        self.children = []
        self.parent = None

    def __repr__(self):
        return self.name


class FileSystemTree:
    def __init__(self):
        self.root = Node("/")  # .../abc/123.txt
        self.now = self.root

    def mkdir(self, name):
        # name 以 / 结尾
        if name[-1] != "/":
            name += "/"
        node = Node(name)
        self.now.children.append(node)
        node.parent = self.now

    def ls(self):
        return self.now.children

    def cd(self, name):
        if name[-1] != "/":
            name += "/"

        for child in self.now.children:
            if child.name == name:
                self.now = child
                return
            raise ValueError("invalid dir")


tree = FileSystemTree()
tree.mkdir("var/")
tree.mkdir("bin/")
tree.mkdir("usr/")

tree.cd("bin/")
tree.mkdir("python/")
print(tree.ls())
# print(tree.root.children)

3.二叉树

class BiTreeNode:
    def __init__(self, data):
        self.data = data
        self.lchild = None
        self.rchild = None


a = BiTreeNode("A")
b = BiTreeNode("B")
c = BiTreeNode("C")
d = BiTreeNode("D")
e = BiTreeNode("E")
f = BiTreeNode("F")
g = BiTreeNode("G")

e.lchild = a
e.rchild = g
a.rchild = c
c.lchild = b
c.rchild = d
g.rchild = f

root = e
print(root.lchild.rchild.data)

4.二叉树的遍历

from collections import deque


class BiTreeNode:
    def __init__(self, data):
        self.data = data
        self.lchild = None
        self.rchild = None


a = BiTreeNode("A")
b = BiTreeNode("B")
c = BiTreeNode("C")
d = BiTreeNode("D")
e = BiTreeNode("E")
f = BiTreeNode("F")
g = BiTreeNode("G")

e.lchild = a
e.rchild = g
a.rchild = c
c.lchild = b
c.rchild = d
g.rchild = f

root = e


# print(root.lchild.rchild.data)

def pre_order(root):
    '''前序遍历'''
    if root:
        print(root.data, end=',')
        pre_order(root.lchild)
        pre_order(root.rchild)


def in_order(root):
    if root:
        in_order(root.lchild)
        print(root.data, end=',')
        in_order(root.rchild)


def post_order(root):
    if root:
        post_order(root.lchild)
        post_order(root.rchild)
        print(root.data, end=',')


def level_order(root):
    queue = deque()
    queue.append(root)
    while len(queue) > 0:  # 只要队列不空
        node = queue.popleft()
        print(node.data, end=',')
        if node.lchild:
            queue.append(node.lchild)
        if node.rchild:
            queue.append(node.rchild)


pre_order(root)
print()
in_order(root)
print()
post_order(root)
print()
level_order(root)

 5.二叉搜索树

5.1插入

import random

class BiTreeNode:
    '''节点'''

    def __init__(self, data):
        self.data = data
        self.lchild = None
        self.rchild = None
        self.parenet = None


class Bst:
    '''二叉搜索树'''

    def __init__(self, li):
        self.root = None
        if li:
            for val in li:
                self.insert_not_recall(val=val)

    def insert(self, node, val):
        '''插入操作——递归的写法'''
        if not node:
            node = BiTreeNode(val)
        elif val < node.data:
            node.lchild = self.insert(node.lchild, val)
            node.lchild.parenet = node
        elif val > node.data:
            node.rchild = self.insert(node.rchild, val)
            node.rchild.parenet = node
        return node

    def insert_not_recall(self, val):
        '''插入操作——非递归写法'''
        p = self.root
        if not p:  # 空树
            self.root = BiTreeNode(val)
            return
        while True:
            if val < p.data:
                if p.lchild:
                    p = p.lchild
                else:  # 左孩子不存在
                    p.lchild = BiTreeNode(val)
                    p.lchild.parenet = p
                    return
            elif val > p.data:
                if p.rchild:
                    p = p.rchild
                else:
                    p.rchild = BiTreeNode(val)
                    p.rchild.parenet = p
                    return
            else:
                return

    def pre_order(self, root):
        '''前序遍历'''
        if root:
            print(root.data, end=',')
            self.pre_order(root.lchild)
            self.pre_order(root.rchild)

    def in_order(self, root):
        '''中序遍历'''
        if root:
            self.in_order(root.lchild)
            print(root.data, end=',')
            self.in_order(root.rchild)

    def post_order(self, root):
        '''后序遍历'''
        if root:
            self.post_order(root.lchild)
            self.post_order(root.rchild)
            print(root.data, end=',')

li = list(range(100))
random.shuffle(li)

tree = Bst(li=[4, 6, 7, 9, 2, 1, 3, 5, 8])
tree.pre_order(tree.root)
print()
tree.post_order(tree.root)
print()
tree.in_order(tree.root)
print()
#-----------------------------------------
tree = Bst(li=li)
tree.pre_order(tree.root)
print()
tree.post_order(tree.root)
print()
tree.in_order(tree.root)

结果：

4,2,1,3,6,5,7,9,8,
1,3,2,5,8,9,7,6,4,
1,2,3,4,5,6,7,8,9,
19,2,1,0,5,3,4,14,10,7,6,8,9,11,13,12,16,15,18,17,28,25,24,22,21,20,23,26,27,49,34,33,30,29,32,31,36,35,48,44,38,37,42,40,39,41,43,45,46,47,76,62,55,52,51,50,54,53,61,56,59,58,57,60,66,64,63,65,75,74,69,68,67,73,71,70,72,83,80,78,77,79,81,82,96,89,85,84,87,86,88,92,91,90,95,93,94,99,98,97,
0,1,4,3,6,9,8,7,12,13,11,10,15,17,18,16,14,5,2,20,21,23,22,24,27,26,25,29,31,32,30,33,35,37,39,41,40,43,42,38,47,46,45,44,48,36,34,50,51,53,54,52,57,58,60,59,56,61,55,63,65,64,67,68,70,72,71,73,69,74,75,66,62,77,79,78,82,81,80,84,86,88,87,85,90,91,94,93,95,92,89,97,98,99,96,83,76,49,28,19,
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,
Process finished with exit code 0

Note：

  • 从二叉搜索树中序遍历可以看出，结果是有序的（升序）

5.2查询

    def query(self, node, val):
        '''查询——递归'''
        if not node:
            return None
        if node.data < val:
            return self.query(node.rchild, val)
        elif node.data > val:
            return self.query(node.lchild, val)
        else:
            return node

    def query_not_recall(self, val):
        '''查找——非递归'''
        # p指向根节点
        p = self.root
        while p:
            if p.data < val:
                # p指向右孩子
                p = p.rchild
            elif p.data > val:
                p = p.lchild
            else:
                return p
        return None

5.3删除

  • 如果要删除的节点是叶子结点：直接删除
  • 如果要删除的节点只有一个孩子：将此节点的父亲与孩子节点连接，然后删除节点
  • 如果要删除的节点有两个孩子：将其右子树的最小节点（该节点最多有一个右孩子）删除，并替换当前节点。（如图）

    def __remove_node_1(self, node):
        ''' 情况1：已知node是叶子结点并且删除它'''
        if not node.parenet:  # 判断根节点
            self.root = None
        if node == node.parenet.lchild:  # 判断node是否是它父亲的左孩子
            node.parenet.lchild = None
        else:  # 否则删掉右孩子
            node.parenet.rchild = None

    def __remove_node2_1(self, node):
        '''情况2-1：已知node只有一个左孩子'''
        if not node.parenet:  # 根节点（删除的节点如果没有父节点，那么根节点为它的左孩子节点）
            self.root = node.lchild
            node.parenet.lchild = None
        elif node == node.parenet.lchild:
            node.parenet.lchild = node.lchild
            node.lchild.parenet = node.parenet
        else:
            node.parenet.rchild = node.lchild
            node.lchild.parenet = node.parenet

    def __remove_node2_2(self, node):
        '''情况2-2：已知node只有一个右孩子'''
        if not node.parenet:
            self.root = node.rchild
        elif node == node.parenet.lchild:
            node.parenet.lchild = node.rchild
            node.rchild.parenet = node.parenet
        else:
            node.parenet.rchild = node.rchild
            node.rchild.parenet = node.parenet

    def delete(self, val):
        if self.root:  # 先判断是不是空树
            node = self.query_not_recall(val)
            if not node:  # 树中不存在这个val
                return False
            if not node.lchild and not node.rchild:  # 情况1：叶子结点
                self.__remove_node_1(node)
            elif not node.rchild:  # 2-1情况：没有右孩子
                self.__remove_node2_1(node)
            elif not node.lchild:  # 2-2情况：没有左孩子
                self.__remove_node2_2(node)
            else:  # 3.两个孩子都有
                min_node = node.rchild
                while min_node.lchild:
                    min_node = min_node.lchild
                node.data = min_node.data
                # delete min_node
                if min_node.rchild:
                    self.__remove_node2_2(min_node)
                else:
                    self.__remove_node_1(min_node)
            node.rchild.parenet = node.parenet

 整体代码：

import random


class BiTreeNode:
    '''节点'''

    def __init__(self, data):
        self.data = data
        self.lchild = None
        self.rchild = None
        self.parenet = None


class Bst:
    '''二叉搜索树'''

    def __init__(self, li):
        self.root = None
        if li:
            for val in li:
                self.insert_not_recall(val=val)

    def insert(self, node, val):
        '''插入操作——递归的写法'''
        if not node:
            node = BiTreeNode(val)
        elif val < node.data:
            node.lchild = self.insert(node.lchild, val)
            node.lchild.parenet = node
        elif val > node.data:
            node.rchild = self.insert(node.rchild, val)
            node.rchild.parenet = node
        return node

    def insert_not_recall(self, val):
        '''插入操作——非递归写法'''
        p = self.root
        if not p:  # 空树
            self.root = BiTreeNode(val)
            return
        while True:
            if val < p.data:
                if p.lchild:
                    p = p.lchild
                else:  # 左孩子不存在
                    p.lchild = BiTreeNode(val)
                    p.lchild.parenet = p
                    return
            elif val > p.data:
                if p.rchild:
                    p = p.rchild
                else:
                    p.rchild = BiTreeNode(val)
                    p.rchild.parenet = p
                    return
            else:
                return

    def query(self, node, val):
        '''查询——递归'''
        if not node:
            return None
        if node.data < val:
            return self.query(node.rchild, val)
        elif node.data > val:
            return self.query(node.lchild, val)
        else:
            return node

    def query_not_recall(self, val):
        '''查找——非递归'''
        # p指向根节点
        p = self.root
        while p:
            if p.data < val:
                # p指向右孩子
                p = p.rchild
            elif p.data > val:
                p = p.lchild
            else:
                return p
        return None

    def __remove_node_1(self, node):
        ''' 情况1：已知node是叶子结点并且删除它'''
        if not node.parenet:  # 判断根节点
            self.root = None
        if node == node.parenet.lchild:  # 判断node是否是它父亲的左孩子
            node.parenet.lchild = None
        else:  # 否则删掉右孩子
            node.parenet.rchild = None

    def __remove_node2_1(self, node):
        '''情况2-1：已知node只有一个左孩子'''
        if not node.parenet:  # 根节点（删除的节点如果没有父节点，那么根节点为它的左孩子节点）
            self.root = node.lchild
            node.parenet.lchild = None
        elif node == node.parenet.lchild:
            node.parenet.lchild = node.lchild
            node.lchild.parenet = node.parenet
        else:
            node.parenet.rchild = node.lchild
            node.lchild.parenet = node.parenet

    def __remove_node2_2(self, node):
        '''情况2-2：已知node只有一个右孩子'''
        if not node.parenet:
            self.root = node.rchild
        elif node == node.parenet.lchild:
            node.parenet.lchild = node.rchild
            node.rchild.parenet = node.parenet
        else:
            node.parenet.rchild = node.rchild
            node.rchild.parenet = node.parenet

    def delete(self, val):
        if self.root:  # 先判断是不是空树
            node = self.query_not_recall(val)
            if not node:  # 树中不存在这个val
                return False
            if not node.lchild and not node.rchild:  # 情况1：叶子结点
                self.__remove_node_1(node)
            elif not node.rchild:  # 2-1情况：没有右孩子
                self.__remove_node2_1(node)
            elif not node.lchild:  # 2-2情况：没有左孩子
                self.__remove_node2_2(node)
            else:  # 3.两个孩子都有
                min_node = node.rchild
                while min_node.lchild:
                    min_node = min_node.lchild
                node.data = min_node.data
                # delete min_node
                if min_node.rchild:
                    self.__remove_node2_2(min_node)
                else:
                    self.__remove_node_1(min_node)

    def pre_order(self, root):
        '''前序遍历'''
        if root:
            print(root.data, end=',')
            self.pre_order(root.lchild)
            self.pre_order(root.rchild)

    def in_order(self, root):
        '''中序遍历'''
        if root:
            self.in_order(root.lchild)
            print(root.data, end=',')
            self.in_order(root.rchild)

    def post_order(self, root):
        '''后序遍历'''
        if root:
            self.post_order(root.lchild)
            self.post_order(root.rchild)
            print(root.data, end=',')


li = list(range(100))
random.shuffle(li)

tree = Bst(li=[4, 6, 7, 9, 2, 1, 3, 5, 8])
tree.pre_order(tree.root)
print()
tree.post_order(tree.root)
print()
tree.in_order(tree.root)
print()
# -------------------插入----------------------
tree = Bst(li=li)
tree.pre_order(tree.root)
print()
tree.post_order(tree.root)
print()
tree.in_order(tree.root)
# -------------------查询----------------------
li1 = list(range(10))
random.shuffle(li1)
tree1 = Bst(li=li1)
print()
print(tree1.query_not_recall(4).data)

为祖国添砖JAVA
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python 数据结构与算法——tree（树）
hftytf的博客
11-15 369
Python 数据结构与算法——tree（树）
Python数据结构与算法笔记（八）：数据结构——树，二叉树和AVL树
AvenueCyy的博客
08-03 532
树 class Node: def __init__(self, name, type='dir'): self.name = name self.type = type #"dir" or "file" self.children = [] self.parent = None # 链式存储 def __repr__(self): return self.name class Fil
LeetCode刷题——树（python语言）
qq_26274961的博客
02-25 1632
LeetCode刷题——树（python语言） 一、树 二、刷题 2.1 二叉树的最大深度 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 示例： 给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7 返回它的最大深度 3 。 解法一：利用DFS（深度优先搜索），每次向下遍历，深度加一。 设置变量temp记录当前节点深度 将temp作
[python刷题模板] 树的直径/换根DP
liuliangcan的博客
01-22 1774
py刷题模板之树的直径/换根DP
数据结构与算法 —— 树的基本操作以及实现（python实现）
最新发布
‘’
05-05 2111
树是由节点和边组成的非线性数据结构。其结构可以用来表示层次关系，例如文件系统的目录结构、公司的组织架构等。本文用python来实现一颗通用树，可以用于构建任何类型的树，如二叉树、多叉树等。定义了一个类Node，并使用Generic[T]表示它是一个泛型类，类型参数为T。在类中定义了四个属性，分别是_value_parent_children和。其中，_value用于存储节点的值，_parent用于存储节点的父节点，_children用于存储节点的子节点列表，用于存储节点的子树大小。__init__
数据结构与算法——树的广度优先遍历
python全栈
11-22 331
实现：往完全二叉树中添加一个节点，使得添加之后这棵树依旧是一棵完全二叉树 class Node: def __init__(self, val): self.val = val # 数据域 self.left = None # 左指针域 self.right = None # 右指针域 class Tree: def __init__(self): self.root = None # 树的根节点 def
python实现二叉树的操作（7种）
wenkenza5368的博客
03-15 2852
二叉树的前序遍历递归def preorder(root,res=[]): if not root: return res.append(root.val) preorder(root.left,res) preorder(root.right,res) return res迭代def preorder(root): res=[] ...
数据结构与算法 Python语言描述
04-19
### 数据结构与算法——Python语言描述 #### 背景介绍 - **Python语言的发展**：21世纪以来，Python已经成为世界上最受欢迎的编程语言之一，被广泛应用于各个领域。因其简洁易懂的语法特性，Python被越来越多的...
零基础征服数据结构算法Python版2023
04-14
分享一套python版的数据结构算法的视频教程——《零基础征服数据结构算法Python版》，2023年4月完结新课，提供配套的代码和课件下载！ 《零基础征服数据结构算法Python版》课程以985院校为授课标准，结合大厂面试所...
常用数据挖掘算法总结及Python实现.pdf
03-10
第七部分，数据结构与算法，讲解了如数组、链表、树、图等基本数据结构以及排序、查找等经典算法，这些都是有效解决数据挖掘问题的基础。 第八部分，SQL知识，介绍了SQL（结构化查询语言），它是处理关系数据库的...
python 遍历_Python实现二叉树的常见遍历操作总结「7种方法」
weixin_40003233的博客
11-24 1525
本文实例讲述了Python实现二叉树的常见遍历操作。分享给大家供大家参考，具体如下：二叉树的定义class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None二叉树的前序遍历递归def preorder(root,res=[]): if not root: return res.appen...
树的操作——python
平凡
05-10 2232
树的广度优先遍历（Python）。 # python写的树的广度优先算法，使用队列这种数据结构。 def level_queue(root): if root is None: return my_queue=[] node=root my_queue.append(node) while my_queue: node=my
数据结构 python：树简单操作
wei_bo_cai的博客
04-22 395
数据结构：树的生成原始数据生成树代码 原始数据 child: 子节点 parent：父节点 如果parent==child，则为根节点（这里是森林的结构） child,parent a,b b,c c,c 生成树 获取根节点 获取父与子的对应关系，利用列表存储每一层的父子对应关系 获取树结构 时间复杂度：层级*每层节点个数的最大值 代码 def main(): original = [{}] data = dict() with open('origin.csv', new
Python实现二叉树的基础操作
MirrorN的博客
01-05 2171
本篇的主要内容： Python实现二叉树的建立与遍历 如何判断完全二叉树 最近遇到这个问题，要使用Python实现二叉树的一些操作，在网上这部分的资源不是很多，也没有找好很好的，只好按照自己的思路简单写了一下，本来算法是不局限于语言的，说是这么说，但是还是遇到了一些问题，在此梳理记录一下。 二叉树建立 首先定义二叉树的先序字符串，并使用#表示某个节点的子树为空的情况： 二叉树类的定义为： cl...
python实现二叉树及相关操作
xskxushaokai的博客
12-14 2007
最近秋招差不多结束了，这几个月复习了不少东西，记录一下用python构造二叉树以及相关的操作,与二叉树相关的操作大多数都可以用递归的方法来解决。本文将记录二叉树的前序遍历、中序遍历、后序遍历、层次遍历、二叉树排序、查询、反转，以及笔试中常遇到的二叉树相关操作。
Python 实现树结构
热门推荐
U R MINE
03-23 8万+
        树在计算机科学的许多领域中使用，包括操作系统，图形，数据库系统和计算机网络。树数据结构与他们的植物表亲有许多共同之处。树数据结构具有根，分支和叶。自然界中的树和计算机科学中的树之间的区别在于树数据结构的根在顶部，其叶在底部。 1 树的相关定义 节点：树的基本部分。它可以有一个名称，我们称之为“键”。节点也可以有附加信息。我们将这个附加信息称为“有效载荷”。虽然有效载荷信息不是...
Python数据结构——树的实现
weixin_34072458的博客
11-25 2708
“嵌套列表”表示树 在用嵌套列表表示树时，我们使用 Python 的列表来编写这些函数。虽然把界面写成列表的一系列方法与我们已实现其他的抽象数据类型有些不同，但这样做比较有意思，因为它为我们提供一个简单、可以直接查看的递归数据结构。在列表实现树时，我们将存储根节点作为列表的第一个元素的值。列表的第二个元素的本身是一个表示左子树的列表。这个...
python有关树的操作
weiqi的博客
01-23 521
1.求树的深度(剑指offer) 递归操作 2.判断树是否为平衡二叉树 #为了节省时间，我们只需判断左右两个子树是否都是一棵平衡二叉树, #当递归到高度差大于1时就返回-1,不用再递归下去浪费时间了 ...
算法中常用的树操作（python）
HevenYin的博客
03-17 579
算法中常用的树操作 树的数据结构 class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None 1、树的子结构 输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构） cla...
Python编程入门：获取帮助与基础知识概览
5. **课程目标**：旨在让学生掌握Python编程的基础知识和技能，包括数据类型和运算的理解、基本结构（顺序、选择、循环）的运用、常用库函数的使用、数据结构设计和简单算法，以及程序设计和调试的技巧。 6. **教材...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值