二叉排序树与AVL树

最新推荐文章于 2023-03-15 08:17:58 发布
原创 最新推荐文章于 2023-03-15 08:17:58 发布 · 1.9k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #算法 #查找

本文介绍了二叉排序树的定义、查找、插入和删除操作，并深入讲解了AVL树的平衡因子、最小不平衡子树的概念，以及插入和删除操作的实现原理和平衡调整策略。通过示例说明了四种不同情况下的旋转操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

二叉排序树

定义：二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：
 （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；
 （2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值；
 （3）左、右子树也分别为二叉排序树；

算法思想：

 查找：查找 k e y key key值，由二叉排序树的定义可以知道，在进行查找操作时，可以先与根节点比较，若比根节点的值小则再与左子树的根节点比较，若比根节点的值大则再与右子树的根节点比较，若与根节点的值相等则查找结束，从描述可以看出，这是一个典型的递归操作。
 插入：插入 k e y key key值，先对于二叉排序树进行 k e y key key值的查找，若没有 k e y key key值再进行插入。对于插入操作，先确定 k e y key key值应该插入的位置，当然 k e y key key值插入进去后是成为二叉排序树的叶子节点。对于查找插入位置，可以设一个新变量 c u r r e n t current current来记录在搜寻合适位置时，当前的节点位置。
 删除：删除操作是二叉排序树中相对而言最复杂的操作。删除 k e y key key值节点 T T T，先对于二叉排序树进行 k e y key key值查找，若存在 k e y key key值再进行删除。对于删除操作，一共有三种情况，若删除的节点 T T T是树中的叶子节点，则直接删除即可；若删除的节点 T T T有且仅有一个孩子节点，则直接将 T T T的双亲节点与 T T T的孩子节点连接即可；若节点 T T T既有左孩子，也有右孩子，则需要从 T T T的左右子树中找到一个节点 R R R来弥补 T T T在树中的位置，即将 R R R替换 T T T，并且从原本 T T T的左右子树中删除掉 R R R，这个节点 R R R需要它的值比 T T T的左子树中所有值都大，又要比 T T T的右子树的所有值都小，故这个节点 R R R可以是 T T T的左子树中的最大值的节点，也可以是 T T T的右子树中最小值的节点。

代码：

# -*- coding: utf-8 -*-
"""
Created on Mon Apr  8 20:16:42 2019

@author: Administrator
"""

class BinaryTree(object):
    def __init__(self,data):
        self.data=data
        self.lchild=None
        self.rchild=None
        self.forth=None

        
    
class BinarySearchTree(object):
    def __init__(self,root=None):
        self.root=root
        self.size=0
        self.head=BinaryTree(None)       #为根节点额外创建一个头节点
        self.root.forth=self.head
        self.head.lchild=self.root
        
            
    def FindMin(self,node):              #寻找以node为根的二叉排序树的最小值所在节点
        if node:
            current=node
            while current.lchild:
                current=current.lchild
            return current
        else:
            return None
    def FindMax(self,node):              #寻找以node为根的二叉排序树的最大值所在节点
        if node:
            current=node
            while current.rchild:
                current=current.rchild
            return current
        else:
            return None


    #查找操作，返回查找结果与节点
    def _SearchBST(self,key,T):
        if not T:
            return False,T
        else:
            if key==T.data:
                return True,T
            elif key<T.data:
                return self._SearchBST(key,T.lchild)
            else:
                return self._SearchBST(key,T.rchild)
    def SearchBST(self,key):
        if self.root:
            result,location=self._SearchBST(key,self.root)
            if result:
                print('查找成功')
                return location
            else:
                print('查找失败')
        else:
            print('空表，查找失败')
    
    #插入操作，需要先判断插入值是否已经存在
    def _InsertBST(self,key):
        node=BinaryTree(key)
        if not self.root:
            self.root=node
            self.size+=1
        else:
            current=self.root
            while True:
                if key<current.data:
                    if current.lchild:
                        current=current.lchild
                    else:
                        current.lchild=node
                        node.forth=current
                        self.size+=1
                        break
                elif key>current.data:
                    if current.rchild:
                        current=current.rchild
                    else:
                        current.rchild=node
                        node.forth=current
                        self.size+=1
                        break
                else:
                    break
    def InsertBST(self,key):
        result,location=self._SearchBST(key,self.root)
        if result:
            print('查找值在二叉查找树中已存在，返回其节点：')
            return location
        else:
            self._InsertBST(key)
            return True
    
    #删除操作，一共有三种情况：该节点无孩子，有一个孩子，有两个孩子
    def _DeleteBST(self,key,T):
        if T.forth.lchild==T:                    #如果要删除的节点为它双亲节点的左节点
            if T.rchild and T.lchild:            #T有两个孩子
                node=self.FindMin(T.rchild)
                self._DeleteBST(node.data,node)
                node.lchild=T.lchild
                node.rchild=T.rchild
                node.forth=T.forth
            elif T.lchild and not T.rchild:      #T只有一个孩子
                T.lchild.forth=T.forth
                T.forth.lchild=T.lchild
            elif not T.lchild and T.rchild:
                T.rchild.forth=T.forth
                T.forth.lchild=T.rchild
            else:
                T.forth.lchild=None              #T没有孩子
        else:                                    #如果要删除的节点为它双亲节点的右节点
            if T.rchild and T.lchild:
                node=self.FindMin(T.rchild)
                self._DeleteBST(node.data,node)
                node.lchild=T.lchild
                node.rchild=T.rchild
                node.forth=T.forth
            elif T.lchild and not T.rchild:
                T.lchild.forth=T.forth
                T.forth.rchild=T.lchild
            elif not T.lchild and T.rchild:
                T.rchild.forth=T.forth
                T.forth.rchild=T.rchild
            else:
                T.forth.rchild=None
    def DeleteBST(self,key):
        result,T=self._SearchBST(key,self.root)
        if not result:
            print('删除值在原表中不存在，删除失败')
        else:
            self._DeleteBST(key,T)
            self.root=self.head.lchild
            return True

 
 

平衡二叉树(AVL树)

 定义：平衡二叉树 ( S e l f − B a l a n c i n g   B i n a r y   S e a r c h   T r e e   或   H e i g h t − B a l a n c e d   B i n a r y   S e a r c h   T r e e ) (Self-Balancing\ Binary\ Search\ Tree\ 或\ Height-Balanced\ Binary\ Search\ Tree) (Self−Balancing Binary Search Tree 或 Height−Balanced Binary Search Tree)，是一种二叉排序树，其中每一个节点的左子树和右子树的高度差的绝对值至多等于1 。
 平衡因子：将二叉树上结点的左子树高度减去右子树高度的值称为平衡因子 B F ( B a l a n c e   F a c t o r ) BF(Balance\ Factor) BF(Balance Factor)。
 最小不平衡子树：距离插入结点最近的，且平衡因子的绝对值大于1的结点 T T T，以 T T T为根的子树，我们称为最小不平衡子树。

实现基本原理

 插入操作实现原理：平衡二叉树构建的基本思想就是在构建二叉排序树的过程中，每当插入一个结点时，先检查是否因插入而破坏了树的平衡性，若是，则找出最小不平衡子树。在保持二叉排序树特性的前提下，调整最小不平衡子树中各结点之间的链接关系，进行相应的旋转，使之成为新的平衡子树。在代码实现过程中，需要注意的细节有两处，一个是关于旋转方式，另一个则是旋转后节点的高度的变动。
 则插入节点从而破坏平衡性的情况有如此四种：(设最小不平衡子树的根节点为 P P P)
 情况1.对 P P P的左孩子的左子树进行一次插入，此时只需对整个最小不平衡子树进行一此右旋转即可。
情况1
 情况2.对 P P P的左孩子的右子树进行一次插入，此时需要先对以 C C C为根的子树进行左旋转，再对局部旋转后得到的以P为根的子树进行右旋转。
情况2
 情况3.对 P P P的右孩子的左子树进行一次插入，此时需要先对以 C C C为根的子树进行右旋转，再对局部旋转后得到的以P为根的子树进行左旋转。

情况3
 情况4.对 P P P的右孩子的右子树进行一次插入，此时只需对以 P P P为根的子树进行左旋转即可。
情况4
 删除操作的实现原理：
 节点的删除有以下四种情况：
 情况1.当前节点为要删除的节点且是树叶（无子树），直接删除，当前节点(为None)的平衡不受影响。
 情况2.当前节点为要删除的节点且只有一个左孩子或右孩子，用左孩子或右孩子代替当前节点，当前节点的平衡不受影响。
 情况3.当前节点为要删除的节点且有左子树与右子树：如果右子树高度较高，则从右子树选取最小节点，将其值赋予当前节点，然后删除右子树的最小节点。如果左子树高度较高，则从左子树选取最大节点，将其值赋予当前节点，然后删除左子树的最大节点。这样操作当前节点的平衡不会被破坏。
 情况4.当前节点不是要删除的节点，则对其左子树或者右子树进行递归操作。当前节点的平衡条件可能会被破坏，需要进行平衡操作。进行平衡操作也有四种情况，和插入操作时的四种情况相同。

代码

节点：

class BinaryTree(object):
    def __init__(self,data):
        self.data=data
        self.lchild=None
        self.rchild=None
        self.height=0

AVL_Tree：成员：

class AVL_Tree(object):
    def __init__(self):
        self.root=None

AVL_Tree：节点高度获取方法：

def get_Height(self,T):#获取节点高度
    if not T:
    #用于计算T的祖先的高度，方便在删除T后，其祖先的高度进行-1操作时方便
        return -1      
    else:
        return T.height

AVL_Tree：树的旋转(注意关于节点的高度的赋值)：

def _R_single_Rotate(self,T):           #右旋转
    L=T.lchild
    T.lchild=L.rchild
    L.rchild=T
    T.height=max(self.get_Height(T.lchild),self.get_Height(T.lchild))+1
    L.height=max(self.get_Height(L.lchild),self.get_Height(L.lchild))+1
    return L
    
def _L_single_Rotate(self,T):           #左旋转
    L=T.rchild
    T.rchild=L.lchild
    L.lchild=T
    T.height=max(self.get_Height(T.lchild),self.get_Height(T.lchild))+1
    L.height=max(self.get_Height(L.lchild),self.get_Height(L.lchild))+1
    return L
    
def _R_double_Rotate(self,T):           #先对T的左孩子进行左旋转，再对T进行右旋转
    T.lchild=self._L_single_Rotate(T.lchild)
    return self._R_single_Rotate(T)
        
def _L_double_Rotate(self,T):           #先对T的右孩子进行右旋转，再对T进行左旋转
    T.rchild=self._R_single_Rotate(T.rchild)
    return self._L_single_Rotate(T)

AVL_Tree：插入方法：

    def _Insert_AVL(self,key,T):
        if not T:
            T=BinaryTree(key)
        else:
            if key<T.data:
                T.lchild=self._Insert_AVL(key,T.lchild)
                if self.get_Height(T.lchild)-self.get_Height(T.rchild)==2:
                    if key<T.lchild.data:
                        T=self._R_single_Rotate(T)
                    else:
                        T=self._R_double_Rotate(T)
            elif key>T.data:
                T.rchild=self._Insert_AVL(key,T.rchild)
                if self.get_Height(T.rchild)-self.get_Height(T.lchild)==2:
                    if key<T.rchild.data:
                        T=self._L_double_Rotate(T)
                    else:
                        T=self._L_single_Rotate(T)
            else:
                raise KeyError('Error,key in tree!')
        T.height=max(self.get_Height(T.lchild),self.get_Height(T.rchild))+1
        #因为虽然在插入操作中，进行旋转时对变动的节点高度进行了重新赋值，
        #但是对于那些节点的祖先，并没有对其高度重新赋值，在旋转过后，
        #其祖先节点的高度可能会发生变化。
        
        return T
    
    def Insert_AVL(self,key):
        if self.root:
            self.root=self._Insert_AVL(key,self.root)
        else:
            self.root=BinaryTree(key)

AVL_Tree：删除方法：

def _get_Min(self,T):                   #寻找节点T所对应子树的最小值节点
    if T:
        if T.lchild:
            return self._get_Min(T.lchild)
        else:
            return T
    else:
        return None
        
def _get_Max(self,T):                #寻找节点T所对应子树的最大值节点
    if T:
        if T.rchild:
            return self._get_Max(T.rchild)
        else:
            return T
    else:
        return None

def _Delete_AVL(self,key,T):
    if T is None:
        raise KeyError('Error,key not in tree')
    elif key<T.data:
        T.lchild=self._Delete_AVL(key,T.lchild)
        if self.get_Height(T.rchild)-self.get_Height(T.lchild)==2:
            if self.get_Height(T.rchild.rchild)>=self.get_Height(T.rchild.lchild):
                T=self._L_single_Rotate(T)
            else:
                T=self._L_double_Rotate(T)
    elif key>T.data:
        T.rchild=self._Delete_AVL(key,T.rchild)
        if self.get_Height(T.lchild)-self.get_Height(T.rchild)==2:
            if self.get_Height(T.lchild.lchild)>=self.get_Height(T.lchild.rchild):
                T=self._R_single_Rotate(T)
            else:
                T=self._R_double_Rotate
    elif T.lchild and T.rchild:
        if self.get_Height(T.lchild)>=self.get_Height(T.rchild):
            node=self._get_Max(T.lchild)
            T.data=node.data
            T.lchild=self._Delete_AVL(node.data,T.lchild)
        else:
            node=self._get_Min(T.rchild)
            T.data=node.data
            T.rchild=self._get_Min(node.data,T.rchild)
    else:
        if T.rchild:
            T=T.rchild
        else:
            T=T.lchild

    if T:
        T.height=max(self.get_Height(T.lchild),self.get_Height(T.rchild))+1
            
        return T
        
def Delete_AVL(self,key):
    self.root=self._Delete_AVL(key,self.root)

AVL_Tree：查找方法：

def _Search_AVL(self,key,T):
    if T:
        if key<T.data:
            return self._Search_AVL(key,T.lchild)
        elif key>T.data:
            return self._Search_AVL(key,T.rchild)
        else:
            return T
    else:
        raise KeyError('key not in tree')
def Search_AVL(self,key):
    return self._Search_AVL(key,self.root)			 #返回查找到的节点

完整代码

# -*- coding: utf-8 -*-
"""
Created on Tue Apr  9 16:11:47 2019

@author: Administrator
"""

class BinaryTree(object):
    def __init__(self,data):
        self.data=data
        self.lchild=None
        self.rchild=None
        self.height=0
   
class AVL_Tree(object):
    def __init__(self):
        self.root=None
    
    def get_Height(self,T):            #获取节点高度，如果节点为None，则高度为-1，此举方便对节点的高度进行计算
        if not T:
            return -1                     #用于计算node的祖先的高度，方便在删除node后，其祖先的高度进行-1操作时方便
        else:
            return T.height
        
    def _R_single_Rotate(self,T):                 #右旋转
        L=T.lchild
        T.lchild=L.rchild
        L.rchild=T
        T.height=max(self.get_Height(T.lchild),self.get_Height(T.lchild))+1
        L.height=max(self.get_Height(L.lchild),self.get_Height(L.lchild))+1
        return L

    def _L_single_Rotate(self,T):                 #左旋转
        L=T.rchild
        T.rchild=L.lchild
        L.lchild=T
        T.height=max(self.get_Height(T.lchild),self.get_Height(T.lchild))+1
        L.height=max(self.get_Height(L.lchild),self.get_Height(L.lchild))+1
        return L
    
    def _R_double_Rotate(self,T):           #先对T的左孩子进行左旋转，再对T进行右旋转
        T.lchild=self._L_single_Rotate(T.lchild)
        return self._R_single_Rotate(T)
        
    def _L_double_Rotate(self,T):           #先对T的右孩子进行右旋转，再对T进行左旋转
        T.rchild=self._R_single_Rotate(T.rchild)
        return self._L_single_Rotate(T)
        
    def _get_Min(self,T):                   #寻找节点T所对应子树的最小值节点
        if T:
            if T.lchild:
                return self._get_Min(T.lchild)
            else:
                return T
        else:
            return None
        
    def _get_Max(self,T):                #寻找节点T所对应子树的最大值节点
        if T:
            if T.rchild:
                return self._get_Max(T.rchild)
            else:
                return T
        else:
            return None
    
    def _Search_AVL(self,key,T):
        if T:
            if key<T.data:
                return self._Search_AVL(key,T.lchild)
            elif key>T.data:
                return self._Search_AVL(key,T.rchild)
            else:
                return T
        else:
            raise KeyError('key not in tree')
    def Search_AVL(self,key):
        return self._Search_AVL(key,self.root)
    
    def _Insert_AVL(self,key,T):
        if T is None:
            T=BinaryTree(key)
        else:
            if key<T.data:
                T.lchild=self._Insert_AVL(key,T.lchild)
                if self.get_Height(T.lchild)-self.get_Height(T.rchild)==2:
                    if key<T.lchild.data:
                        T=self._R_single_Rotate(T)
                    else:
                        T=self._R_double_Rotate(T)
            elif key>T.data:
                T.rchild=self._Insert_AVL(key,T.rchild)
                if self.get_Height(T.rchild)-self.get_Height(T.lchild)==2:
                    if key<T.rchild.data:
                        T=self._L_double_Rotate(T)
                    else:
                        T=self._L_single_Rotate(T)
            else:
                raise KeyError('Error,key in tree!')
        T.height=max(self.get_Height(T.lchild),self.get_Height(T.rchild))+1
        return T
    
    def Insert_AVL(self,key):
        if self.root:
            self.root=self._Insert_AVL(key,self.root)
        else:
            self.root=BinaryTree(key)

    def _Delete_AVL(self,key,T):
        if T is None:
            raise KeyError('Error,key not in tree')
        elif key<T.data:
            T.lchild=self._Delete_AVL(key,T.lchild)
            if self.get_Height(T.rchild)-self.get_Height(T.lchild)==2:
                if self.get_Height(T.rchild.rchild)>=self.get_Height(T.rchild.lchild):
                    T=self._L_single_Rotate(T)
                else:
                    T=self._L_double_Rotate(T)
        elif key>T.data:
            T.rchild=self._Delete_AVL(key,T.rchild)
            if self.get_Height(T.lchild)-self.get_Height(T.rchild)==2:
                if self.get_Height(T.lchild.lchild)>=self.get_Height(T.lchild.rchild):
                    T=self._R_single_Rotate(T)
                else:
                    T=self._R_double_Rotate
        elif T.lchild and T.rchild:
            if self.get_Height(T.lchild)>=self.get_Height(T.rchild):
                node=self._get_Max(T.lchild)
                T.data=node.data
                T.lchild=self._Delete_AVL(node.data,T.lchild)
            else:
                node=self._get_Min(T.rchild)
                T.data=node.data
                T.rchild=self._get_Min(node.data,T.rchild)
        else:
            if T.rchild:
                T=T.rchild
            else:
                T=T.lchild
        
        if T:
            T.height=max(self.get_Height(T.lchild),self.get_Height(T.rchild))+1
            
        return T
    def Delete_AVL(self,key):
        self.root=self._Delete_AVL(key,self.root)

注释

关于AVL树的的旋转示意图，借鉴于博客园的一位博主：再见紫罗兰的博文，代码方面和他的代码也没有多大的差异。原文链接：
https://www.cnblogs.com/linxiyue/p/3659448.html?utm_source=tuicool&utm_medium=referral

通俗易懂的图解二叉搜索树、AVL树和红黑树
暗色光的博客
07-06 653
搜索是一种很常见的需求，当数据较多时，如何找到目标对象时，即需要搜索查找。 那么如何快速找到目标呢，最朴素的思想就是暴力查找，一个一个对比。 显然，当数据量增大时，我们需要优化查找方法获取更快的查找速度，我们可以通过维护一个有序数组，从而实现二分查找，查找速度从O(n)降为O(longn)。 但是数组并不便于插入和删除，链表便成为了最好的选择。 既然是采用二分查找，那么不如直接按照查找的步骤维护一种数据结构，于是二叉搜索树出现了。 二叉搜索树的性质为： 若左子树不为空，则左子树上所有节点值都小于根结点值；
二叉树-详解平衡二叉排序树AVL
yixianfeng41的专栏
11-19 4271
平衡二叉搜索树AVL也许因为输入值不够随机，也许因为输入顺序的原因，还或许一些插入、删除操作，会使得二叉搜索树失去平衡，造成搜索效率低落的情况。 比如上面两个树，在平衡树上寻找15就只要2次查找，在非平衡树上却要5次查找方能找到，效率明显下降。那么什么叫“平衡”，直观上的最佳平衡条件就是 每个节点的左右子树有着相同高度，但这确实太过苛刻。平衡二叉树AVL tree退而求其次，要求任何节
二叉排序树和AVL树
qq_51340322的博客
08-28 1576
二叉排序树和AVL树 文章目录二叉排序树和AVL树一、二叉排序树1. 理论定义(1)、什么是二叉排序树(2)、简单介绍二叉排序树2. 模拟画图3. 要点分析4. 代码实现(1)、定义结构体：(2)、插入新节点：(3)、层序遍历：(4)、中序遍历：中序遍历二叉排序树可得到有序序列(5)、完整代码：二、AVL树1. 理论定义2. 模拟旋转3. 代码实现 引言：本文视频链接全部来自bilibili，因为是在bilibili大学上学qwq 一、二叉排序树 1. 理论定义 (1)、什么是二叉排序树 ​
DataStructures - 05：二叉排序树与AVL树
你今天真好看呀
04-04 290
文章目录1、二叉排序树BST1.1 创建二叉排序树并遍历1.2 二叉排序树删除节点2、平衡二叉排序树AVL树2.1 左旋转2.2 右旋转2.3 双旋转 1、二叉排序树BST Binary Sort Tree：对于二叉排序树的任何一个非叶子节点，要求其左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。 1.1 创建二叉排序树并遍历 将一个数组创建成对应的二叉排序树，并使用中序遍历二叉排序...
数据结构-二叉搜索树与AVL树
Coder Liu的博客
07-07 580
二叉搜索树 二叉搜索树属于二叉树,具有如下的性质: 1.节点的左子树不为空,那么左子树所有的节点的值都小于该节点的值 2.节点的右子树不为空,那么右子树所有的节点的值都大于该节点的值. 3.节点的左右子树都是二叉搜索树. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e2zyxSEF-1594085941066)(evernotecid://8BF4008B-52C0-484E-A4B5-8EBD45F20215/appyinxiangcom/13973009/ENResou
二叉查找树及Avl树
weixin_41677899的博客
11-26 221
定义不再叙述，看程序 应该是这本书，我看的第二版 https://book.douban.com/subject/10530466/ 下面是二叉查找树，我认为比较好的一点是在插入的时候返回修改的子树，代替了c里面的指针，这是我看c数据结构想改写为java时所没有想到的。 还有一点，用户在插入时是不知道root的，而插入函数需要root，所以要有两个插入函数,一个是外部的，只传入值;一个是内部的，传...
二叉排序树_17281183_刘梦婷_leavingtbk_二叉排序树_
10-01
二叉排序树，又称二叉查找树或二叉搜索树，...二叉排序树的优化版本，如平衡二叉排序树（如AVL树和红黑树），更是广泛应用于数据库索引、文件系统等领域。因此，对二叉排序树的学习和掌握是IT专业人员必备的技能之一。
构建二叉排序树与AVL树的实践与应用
本篇实验报告是关于计算机科学与工程学院（互联网+）的学生李逢君在2018年进行的数据结构与算法课程实验，主要涉及的主题是二叉树的应用，具体实验内容包括二叉排序树（BST）和平衡二叉树（AVL）的构造与实现。...
二叉排序树与AVL树课程设计：操作与性能分析
在数据结构与算法设计的课程设计中，重点研究了二叉排序树和平衡二叉树的相关内容。首先，课程设计的目标旨在深化理解数据结构中的基本概念，如二叉树的性质和操作，以及程序设计的核心思想和方法。通过实际操作，...
实现二叉排序树的各种算法
07-25
为了维持高效，可能会涉及到平衡操作，如AVL树和红黑树等自平衡二叉排序树的实现。 在"综合性实验报告"中，学生可能会详细介绍这些算法的实现细节，包括用到的数据结构（如节点定义）、主要的函数（如insert、...
二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造 课设作业 完整代码
02-10
其定义为：二叉排序树或者是空树，或者是满足如下性质的二叉树：1.若它的左子树非空，则左子树上所有结点的值均小于根结点的值；2.若它的右子树非空，则右子树上所有结点的值均大于根结点的值；3.左、右子树本身又各...
二叉搜索树和AVL树（红黑树前奏）
冲冲冲的博客
10-22 316
二叉搜索树和AVL树 二叉树是指树的每个节点最多只能有两个子节点，如果我们给二叉树加上以下条件，就可以得到二叉搜索树 二叉搜索树要求： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。 二叉搜索树查找节点： ①、查找值比当前节点值大，则搜索右子树； ②、查找值等于当前节点值，停止搜索（终止条件）； ③、查找值小于当前节点值，则搜索左子树； 二叉搜索树插入节点： 要插入节点，必须先找到插
二叉搜索树与AVL树
DayDayUp
01-05 1013
目录 二叉搜索树 AVL树 AVL树的旋转 LL旋转 LR旋转 RR旋转 RL旋转 二叉搜索树 二叉查找树(Binary Search Tree)，(又:二叉搜索树，二叉排序树)它或者是一棵空树，或者是具有下列性质的二叉树: 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值; 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值; 它的左、右子树也分别为二叉排序树。左小右大：小于根节点的数放左边，大于根节点的数放右边。重复的节点值不允许出现 二叉搜索树中序遍历得到的值.
数据结构—二叉查找树和AVL树
杨建军的博客
05-20 638
一、二叉查找树1、概念：二、AVL树
【数据结构与算法之树结构】二叉排序树与AVL树
谢谢你们的关注
03-15 166
因为二叉排序树主要用作动态查找表，也就是表结构可以在查找的过程中动态生成，所以插入节点的操作通常在查找不成功时进行，而且新插入节点一定是查找路径上最后一个节点的左孩子或右孩子，插入后二叉树仍然是一棵二叉排序树。第2种方法是用P节点在中序遍历序列中的直接前驱，即S，代替P节点，这样S节点就从原来的位置上被删除，S节点的左子树。删除的节点为P，P是二叉排序树的叶子节点，直接删除即可( 修改该叶子节点的双亲节点的指针域)。要删除的节点为P，双亲节点为Q，且P节点既有左子树。变为S的右子树，然后将P 的左子树。
数据结构与算法(Java)之二叉排序树与AVL树
weixin_42284219的博客
09-08 159
二叉排序数 package com.weeks.tree.binarysorttree; /** * @author 达少 * @version 1.0 * 二叉排序树： * 每个结点的左子结点的值小于当前结点的值，右子结点的大于当前结点的值 * 如果有相同的值则放在左子结点或右子结点（下面的示例放在右子结点上） */ public class BinarySortTreeDemo { public static void main(String[] args) { i
平衡二叉树、AVL树
nameofcsdn的博客
03-04 2799
一，平衡无序二叉树 其实并没有“平衡无序二叉树”这个词，但是“平衡二叉树”这个词的概念一直有两个流派，为了区分，我发明了这个词。 如果一个二叉树满足任意节点的俩子树的高度差都小于等于1，那么它就是平衡无序二叉树。 完全二叉树就是一种平衡无序二叉树。 PS：如若任意节点的俩子树的高度差都为0，那它就只能是满二叉树了。 二，平衡排序二叉树（Self-balancing binary search tree） 如果一个二叉树，既是平衡无序二叉树，又是二叉搜索树（二叉排序树），则称之为...
数据结构--树结构：二叉排序树，二叉搜索树、AVL
积跬步，至千里
03-03 280
关于树的几个概念 树：非线性结构，数据元素之间的逻辑关系时前驱唯一而后续不唯一，即数据元素之间是一对多关系。 二叉树：每个结点最多有两个子树；左右子树是有序的，次序不能颠倒；即使树中只有一个结点，也要区分左右子树。 满二叉树：所有分支结点都存在左右子树，并且所有叶子都在同一层上。 完全二叉树：对一棵具有n个结点的二叉树按层序编号，如果编号为i的结点与同样深度的满二叉树中编号为i的结点...
数据结构学习 —— 二叉树（二叉排序、AVL平衡二叉树C#实现）
布衣大侠的博客
01-07 391
二叉树 每个节点最多有两颗子数； 左右子树有序，不能颠倒 即使某个节点中只有一颗子树，也要区分是左右；如上图所示：节点C是节点A的右子树，节点F是节点C的右子树。 特殊的二叉树： 1、斜树：所有节点都只有左子节点或都只有右子节点 2、满二叉树：在一颗二叉树中，所有的分支节点都存在左子树和右子树，并且所有叶子节点都在同一层，这样的二叉树称为满二叉树。 3、完全二叉树：对一颗具有n个结点的二叉树按层序编号，如果编号为i(1<=i<=n)的节点同样深度的满二叉树中编号为i的节点在二叉树中的位置完
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值