数据结构之二叉搜索树与AVL树

最新推荐文章于 2024-10-05 15:32:05 发布
最新推荐文章于 2024-10-05 15:32:05 发布
阅读量76 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45199760/article/details/129249370
版权

二叉搜索树

若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
它的左、右子树也分别为二叉排序树

在这里插入图片描述

平衡二叉搜索树

平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
在这里插入图片描述

代码


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

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

    #插入
    def insert(self,node,val):       #递归
        if not node:     #node为空
            node=BiTreeNode(val)

        elif val< node.data:
            node.lchild=self.insert(node.lchild,val)
            node.lchild.parent=node

        elif val>node.data:
            node.rchild=self.insert(node.rchild,val)
            node.rchild.parent=node

        return node

    def insert_no_rec(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.parent=p
                    return
            elif val>p.data:
                if p.rchild:
                    p=p.rchild
                else:
                    p.rchild=BiTreeNode(val)
                    p.rchild.parent=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 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

    #删除
    # 情况一：node是叶子结点
    def __remove_node_1(self,node):
        if not node.parent:    # node.parent为空，只有根的父节点为空，即当前节点为根节点的时候，进行以下操作
            self.root=None

        if node ==node.parent.lchild:    #node是父节点的左孩子
            node.parent.lchild=None
        else:
            node.parent.rchild=None

    #情况二：node只有一个左孩子
    def __remove_node_21(self,node):
        if not node.parent:                 #如果要删除的节点为根节点
            self.root=node.lchild         #更新根节点为原来的左孩子
            node.lchild.parent=None       #左孩子现在为根节点，没有父节点

        elif node==node.parent.lchild:      #要删除的节点为父节点的左孩子
            node.parent.lchild=node.lchild   #更新父节点的左孩子为当前节点的左孩子
            node.lchild.parent=node.parent   #更新左孩子的父节点为当前节点的父节点

        else:                                #要删除的节点为其父节点的右孩子
            node.parent.rchild=node.lchild
            node.lchild.parent=node.parent

    #情况三：node只有一个右节点
    def __remove_node_22(self,node):
        if not node.parent:
            self.root=node.rchild
            node.rchild.parent=None

        elif node ==node.parent.lchild:
            node.parent.lchild=node.rchild
            node.rchild.parent=node.parent

        else:
            node.parent.rchild=node.rchild
            node.rchild.parent=node.parent

    def delete(self,val):
        if self.root:    #不是空树
            node=self.query_no_rec(val)
            if not node:  #不存在
                return False
            if not node.lchild and not node.rchild:  #1.左右孩子都为空，即叶子结点
                self.__remove_node_1(node)

            elif not node.rchild:       #2.1只有一个左孩子
                self.__remove_node_21(node)

            elif not node.lchild:       #2.2只有一个右孩子
                self.__remove_node_22(node)

            else:                      #3.3左右孩子都有
                min_node=node.rchild        #找到右孩子最小的节点
                while min_node.lchild:
                    min_node=min_node.lchild
                node.data=min_node.data
                #删除min_node
                if min_node.rchild:       #如果有右节点（min_node肯定没有叶子结点）
                    self.__remove_node_22(min_node)
                else:
                    self.__remove_node_1(min_node)


    def query_no_rec(self,val):   #不使用递归
        p=self.root
        while p:
            if p.data<val:
                p=p.rchild
            if p.data>val:
                p=p.lchild
            else:
                return p
        return None

class AVLNode(BiTreeNode):
    def __init__(self,data):
        BiTreeNode.__init__(self,data)
        self.bf=0

class AVLTree(BST):
    def __init__(self,li=None):
        BST.__init__(self,li)

    def ratate_left(self,p,c):    #左旋
        s2=c.lchild
        p.rchild=s2
        if s2:
            s2.parent=p

        c.lchild=p
        p.parent=c

        p.bf=0
        c.bf=0
        return c

    def ratate_right(self,p,c):  #右旋
        s2=c.rchild
        p.lchild=s2
        if s2:
            s2.parent=p

        c.rchild=p
        p.parent=c

        p.bf=0
        c.bf=0
        return c

    def ratate_right_left(self,p,c):
        g=c.lchild

        s3=g.rchild
        c.lchild=s3
        if s3:
            s3.parent=c
        g.rchild=c
        c.parent=g

        s2=g.lchild
        p.rchild=s2
        if s2:
            s2.parent=p
        g.lchild=p
        p.parent=g

        #更新bf
        if g.bf>0:
            p.bf=-1
            c.bf=0
        elif g.bf<0:
            p.bf=0
            c.bf=1
        else:  #插入的是g
            p.bf=0
            c.bf=0

    def ratate_left_right(self,p,c) :
        g=c.lchild

        s2=g.lchild
        c.rchild=s2
        if s2:
            s2.parent=c
        g.lchild=c
        c.parent=g

        s3=g.rchild
        p.lchild=s3
        if s3:
            s3.parent=p
        g.rchild=p
        p.parent=g

        #更新bf
        if g.bf<0:
            p.bf=1
            c.bf=0

        elif g.bf>0:
            p.bf=0
            c.bf=-1
        else:
            p.bf=0
            c.bf=0

    def insert_no_rec(self,val):
        #1.和BST一样，插入
        p=self.root
        if not p:   #空树
            self.root=AVLNode(val)
            return
        while True:
            if val<p.data:
                if p.child:
                    p=p.lchild
                else:
                    p.lchild=AVLNode(val)
                    p.lchild.parent=p
                    node=p.lchild
                    break
            elif val>p.data:
                if p.rchild:
                    p=p.rchild
                else:
                    p.rchild=AVLNode(val)
                    p.rchild.parent=p
                    node=p.rchild
                    break
            else:
                return

        #2.更新balance factor
        while node.parent:     #node.parent不空
            if node.parent.lchild==node: #传递是从左子树来的，左子树更沉了
                #更新node.parent的bf-=1
                if node.parent.bf<0: #原来的node.bf=-1,更新后变成-2
                    #做旋转
                    #看哪边更沉
                    g=node.parent.parent   #为了连接旋转之后的子树
                    x = node.parent  # 旋转前子树的根
                    if node.bf>0:       #先左旋后右旋
                        n=self.ratate_left_right(node.parent,node)
                    else:
                        n=self.ratate_right(node.parent,node)

                    #记得：把n和g连接起来

                elif node.parent.bf<0:    #原来node.parent.bf=1，更新后变成0
                    node.parent.bf=0
                    break

                else:  #原来node.parent.bf=0，更新后变成-1
                    node.parent.bf=-1
                    node=node.parent
                    continue



            else:     #传递是从右边来的，右子树更沉了
                #更新后的node.parent.bf+=1
                if node.parent.bf>0:    #原来node.parent.bf=1，更新后变成2
                    #做旋转
                    # 看哪边更沉
                    g = node.parent.parent  # 为了连接旋转之后的子树
                    x=node.parent     #旋转前子树的根
                    if node.bf < 0:  # node.bf=1
                        n = self.ratate_right_left(node.parent, node)
                    else:
                        n = self.ratate_left(node.parent, node)

                    # 记得：把n和g连接起来

                elif node.parent.bf < 0:  # 原来node.parent.bf=-1，更新后变成0
                    node.parent.bf = 0
                    break

                else:  # 原来node.parent.bf=0，更新后变成1
                    node.parent.bf = 1
                    node = node.parent
                    continue

            #连接旋转后的子树
            n.parent=g
            if g:   #g不空
                if x==g.lchild:
                    g.lchild=n
                else:
                    g.rchild=n
                break
            else:
                self.root=n
                break



tree=AVLTree([1,2,3,4,5,6,7,8,9])

tree.pre_order(tree.root)
print()
tree.pre_order(tree.root)
乌鸦向北
关注
专栏目录
终于搞懂了什么是二叉查找树，AVL树，B树，B+树，红黑树
wanderlustLee的博客
02-26 1万+
二叉查找树： 二叉查找树就是左结点小于根节点，右结点大于根节点的一种排序树，也叫二叉搜索树。也叫BST，英文Binary Sort Tree。 二叉查找树比普通树查找更快，查找、插入、删除的时间复杂度为O（logN）。但是二叉查找树有一种极端的情况，就是会变成一种线性链表似的结构。此时时间复杂度就变味了O（N），为了解决这种情况，出现了二叉平衡树。   平衡二叉树： 平衡二叉树全称平衡二...
搜索结构之二叉搜索树
summer-yiru
05-16 190
搜索结构之二叉搜索树:二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树      若它的左子树不为空，则左子树上所有节点的值都小于根节点的值      若它的右子树不为空，则右子树上所有节点的值都大于根节点的值      它的左右子树也分别为二叉搜索树二叉搜索树的实现递归和非递归:BSTree.h#pragma once //二叉搜索树---左子树比根节点小,右子树比根节点大...
浙大数据结构第四周之二叉搜索树与平衡二叉搜索树（AVL）
m0_72805195的博客
05-06 584
浙大第四周，大部分题就是复习书上例题，不过那个AVL树的四种旋转挺有挑战性的
数据结构-二叉搜索树与AVL树
Coder Liu的博客
07-07 544
二叉搜索树 二叉搜索树属于二叉树,具有如下的性质: 1.节点的左子树不为空,那么左子树所有的节点的值都小于该节点的值 2.节点的右子树不为空,那么右子树所有的节点的值都大于该节点的值. 3.节点的左右子树都是二叉搜索树. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e2zyxSEF-1594085941066)(evernotecid://8BF4008B-52C0-484E-A4B5-8EBD45F20215/appyinxiangcom/13973009/ENResou
二叉搜索树和AVL树
qq_65285898的博客
04-04 923
二叉搜索树和平衡二叉搜索树
【数据结构】AVL树——平衡二叉搜索树
2301_79796701的博客
05-25 1731
平衡树：左子树的高度等于右子树的高度不平衡树：左子树的高度不等于等于右子树的高度二叉搜索树很难是一颗平衡树。对二叉树进行插入和删除的操作，或插入大量的数据不够随机，都会是使二叉搜索树不够平衡。极端情况下，二叉树会退化成类似链表的结构，那么二叉搜索树查询数据的效率荡然无存。在二叉树的基础上加入平衡的概念就是平衡二叉搜索树，也叫AVL树。AVL树也不是一颗绝对的平衡树，AVL树的平衡是相对的，它允许左子树和右子树的高度为 1 ，但不能超过 1。
二叉搜索树与AVL树
DayDayUp
01-05 920
目录 二叉搜索树 AVL树 AVL树的旋转 LL旋转 LR旋转 RR旋转 RL旋转 二叉搜索树 二叉查找树(Binary Search Tree)，(又:二叉搜索树，二叉排序树)它或者是一棵空树，或者是具有下列性质的二叉树: 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值; 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值; 它的左、右子树也分别为二叉排序树。左小右大：小于根节点的数放左边，大于根节点的数放右边。重复的节点值不允许出现 二叉搜索树中序遍历得到的值.
数据结构-二叉搜索树、AVL树
qq_46895011的博客
11-30 1057
K key;// 关键码E data;// 数据域// 左子女和右子女BSTNode() : left(NULL), right(NULL) {} // 构造函数BSTNode(K x, E d) : key(x), data(d), left(NULL), right(NULL) {} // 构造函数~BSTNode() {} // 析构函数public:BST() : root(NULL) {} // 构造函数~BST() {} // 析构函数// 搜索x// 赋值// 创建。
【Java 数据结构】实现一个二叉搜索树
程序猿教你打篮球的博客
01-09 7023
本期主要讲解： 1、认识二叉搜索树 2、实现一个二叉搜索树 2.1 成员变量 2.2 insert 方法 2.3 search 方法 2.4 remove 方法(重点) 3、二叉搜索树总结
数据结构和算法 十一、二叉搜索树/AVL树
学以致用 知行合一
03-12 400
二叉搜索树遵循某种顺序来排列元素。在二叉搜索树中，左节点的值必须小于父节点，右节点的值必须大于父节点。该规则递归地应用于根的左子树和右子树。
BST.rar_bst_二叉搜索树_数据结构动画_树 动画
09-23
二叉搜索树（BST，Binary Search Tree），是数据结构中一种非常重要的树形数据结构，它的每个节点都包含一个键、一个关联值、一个指向左子节点的引用和一个指向右子节点的引用。在二叉搜索树中，对于任何有效的节点...
基于C语言的数据结构-二叉搜索树bitTree
06-25
二叉搜索树（Binary Search Tree，BST），也称为二叉排序树，是计算机科学中用于组织数据的一种数据结构。在二叉搜索树中，每个节点包含一个键（key）、一个关联的值、一个指向左子节点的引用以及一个指向右子节点的...
数据结构 - 二叉搜索树, AVL树
weixin_41332009的博客
03-27 231
这几天写OS lab写的焦虑爆棚，好在现在写完了lab4/7. 又忙活哥大入学的事情，最终结论是可以先快乐网课一学期。所以最近都没更新博客，my apologies… 1.二叉搜索树 1.1 定义 一个节点的左后代都比它小，右后代都比它大。 对BST做中序遍历，是单调非降的。 1.2 二叉搜索树的查找 对二叉搜索树做查找，相当于对一个有序向量做二分查找。 TreeNode* search(TreeNode* root, int val){ //找到树里值为val的节点，成功时返回该节点，失.
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2721
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
【数据结构】双向链表（Doubly Linked List）
最新发布
2301_77727857的博客
10-05 383
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 1122
本文介绍了数据结构中的AVL树，给出了C++的代码实现
【笔记】数据结构12
m0_52024881的博客
09-29 529
看到的社区的一个知识总结，这里记录一下。
单链表的增删改查（数据结构）
m0_62048999的博客
09-29 1253
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 389
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
C++实现数据结构：二叉搜索树与AVL树的构建与操作
"数据结构用C++描述，包含二叉搜索树、AVL搜索树、B-树和散列及冲突解决的理论与实践题目解答" 在数据结构中，C++是一种常用的语言来实现各种数据结构。本资料主要关注的是二叉搜索树、AVL树、B-树以及散列表等概念...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值