平衡二叉排序树之构建、插入、查找、删除、遍历、平衡旋转

最新推荐文章于 2023-02-10 21:00:07 发布
最新推荐文章于 2023-02-10 21:00:07 发布
阅读量389 收藏 2
点赞数 1
分类专栏： 数据结构与算法 文章标签： 排序算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52711790/article/details/121912401
版权

代码如下：

#include <iostream>
using namespace std;

class AVL{
private:
    int data;		///结点的键值
    int height;		///结点的高度
    AVL* lchild;	///左孩子
    AVL* rchild;	///右孩子
public:
    ///查找最小值
    AVL* FindMin(AVL* avl){
        AVL* cur = avl;
        ///搜索树为空时，返回NULL
        if(cur == NULL){
            return NULL;
        }
        while(cur){
            ///左子树为空时，返回该节点
            if(cur->lchild == NULL){
                return cur;
            }else{///否则在左子树里找最小值
                cur = cur->lchild;
            }
        }
    }

    ///查找最大值
    AVL* FindMax(AVL* avl){
        AVL* cur = avl;
        ///搜索树为空时，返回NULL
        if(cur == NULL){
            return NULL;
        }
        while(cur){
            ///右子树为空时,返回该节点
            if(cur->rchild == NULL){
                return cur;
            }else{      ///否则在左子树里找最小值
                cur = cur->rchild;
            }
        }
    }

    ///插入函数
    AVL* Insert(AVL* avl,int data){
        ///平衡二叉树为空，则构建根节点
        if(!avl){
            avl = new AVL;
            avl->data = data;
            avl->height = 0;
            avl->lchild = avl->rchild = NULL;
        }else if(data < avl->data){    ///若data小于根节点的值，则插入到左子树
            avl->lchild = avl->Insert(avl->lchild,data);
            int rheight = this->getHeight(avl->rchild);		///右子树高度
            int lheight = this->getHeight(avl->lchild);		///左子树高度
            ///如果插入导致左子树失衡，即左子树比右子树高2
            if(lheight - rheight == 2){
                if(data <avl->lchild->data){
                    ///插入的结点比左孩子的键值小
                    ///那么一定是插入到左孩子的左子树上，故进行LL旋转
                    avl = this->SingleLeftRotation(avl);
                }else{    ///否则是插入到左孩子的右子树上，故要进行LR旋转
                    avl = this->DoubleLeftRightRotation(avl);
                }
            }
        }else if(data > avl->data){    ///若data小于根节点的值，则插入到左子树
            avl->rchild = avl->Insert(avl->rchild,data);
            int rheight = this->getHeight(avl->rchild);		///右子树高度
            int lheight = this->getHeight(avl->lchild);		///左子树高度
            ///如果插入导致右子树失衡，即右子树比左子树高2
            if(rheight - lheight == 2){
                if(data > avl->rchild->data){
                    ///插入的结点比右孩子的键值大
                    ///那么一定是插入到右孩子的右子树上，故进行RR旋转
                    avl = this->SingleRightRotation(avl);
                }else{///否则是插入到右孩子的左子树上，故要进行RL旋转
                    avl = this->DoubleRightLeftRotation(avl);
                }
            }
        }
        ///更新结点的高度
        avl->height = this->Max(this->getHeight(avl->lchild),this->getHeight(avl->rchild))+1;
        return avl;
    }

    ///二叉搜索树的构造,利用data数组构造二叉搜索树
    AVL* Create(int* data,int size){
        AVL* avl = NULL;
        for(int i = 0 ; i < size ; i++){
            avl = this->Insert(avl,data[i]);
        }
        return avl;
    }

    ///删除操作
    AVL* Delete(AVL* avl,int data){
        if(!avl){///树空时，直接返回NULL
            return avl;
        }else if(data < avl->data){
            ///data小于根节点时，到左子树去删除data,则有可能使右子树比左子树高2
            avl->lchild = this->Delete(avl->lchild,data);
            int rheight = this->getHeight(avl->rchild);		///右子树高度
            int lheight = this->getHeight(avl->lchild);		///左子树高度
            if(rheight - lheight == 2){//右子树比左子树高2时
                if(data > avl->rchild->data){
                    ///如果是data比右子树的键值大，在右子树的右子树上，则进行RR旋转
                    avl = this->SingleRightRotation(avl);
                }else{  ///否则是data比右子树的键值小，在右子树的左子树上，则进行RL旋转
                    avl = this->DoubleRightLeftRotation(avl);
                }
            }
        }else if(data > avl->data){
            ///data大于根节点时，到右子树去删除data
            avl->rchild = this->Delete(avl->rchild,data);
            int rheight = this->getHeight(avl->rchild);		//右子树高度
            int lheight = this->getHeight(avl->lchild);		//左子树高度
            if(lheight - rheight == 2){//左子树比右子树高2时
                if(data < avl->lchild->data){
                    ///如果是data比左子树的键值小，在左子树的左子树上，则进行LL旋转
                    avl = this->SingleLeftRotation(avl);
                }else{   ///否则是data比左子树的键值大，在左子树的右子树上，则进行LR旋转
                    avl = this->DoubleLeftRightRotation(avl);
                }
            }
        }else{   ///data等于根节点时
            if(avl->lchild && avl->rchild){
                ///左右子树都不空时，用右子树的最小来代替根节点
                AVL* tmp = this->FindMin(avl->rchild);
                avl->data = tmp->data;
                ///删除右子树的最小结点
                avl->rchild = this->Delete(avl->rchild,tmp->data);
            }else{   ///当左右子树都为空或者有一个空时
                AVL* tmp = avl;
                if(!avl->lchild){     ///左子树为空时
                    avl = avl->rchild;
                }else if(!avl->rchild){     ///右子树为空时
                    avl = avl->lchild;
                }
                delete tmp;
            }
        }
        return avl;
    }

    ///单左旋：左左旋函数
    ///左子树的左子树导致的失衡，把左子树与根结点进行调整
    ///根结点的左孩子做根结点，之前的根结点做现在根结点的右孩子
    ///这是因为平衡二叉树一定是二叉搜索树的缘故导致的
    AVL* SingleLeftRotation(AVL* avl){
        ///注意：avl必须有一个左子结点tmp
        ///将avl与tmp做左单旋，更新avl与tmp的高度，返回新的根结点tmp
        AVL* tmp = avl->lchild;
        avl->lchild = tmp->rchild;
        tmp->rchild = avl;
        avl->height = this->Max(this->getHeight(avl->lchild),this->getHeight(avl->rchild))+1;
        tmp->height = this->Max(this->getHeight(tmp->lchild),this->getHeight(avl))+1;
        return tmp;
    }

    ///单右旋：右右旋函数
    ///右子树的右子树导致的失衡，把右子树与根结点进行调整
    ///根结点的右孩子做根结点，之前的根结点做现在根结点的左孩子
    ///这是因为平衡二叉树一定是二叉搜索树的缘故导致的
    AVL* SingleRightRotation(AVL* avl){
        ///注意：avl必须有一个右子结点tmp
        ///将avl与tmp做右单旋，更新avl与tmp的高度，返回新的根结点tmp
        AVL* tmp = avl->rchild;
        avl->rchild = tmp->lchild;
        tmp->lchild = avl;
        avl->height = this->Max(this->getHeight(avl->lchild),this->getHeight(avl->rchild))+1;
        tmp->height = this->Max(this->getHeight(tmp->rchild),this->getHeight(avl))+1;
        return tmp;
    }

    ///左右旋转：LR旋转，左子树的右子树插入导致对的失衡
    AVL* DoubleLeftRightRotation(AVL* avl){
        ///注意：avl必须有一个左子结点B，且B必须有一个右子结点C
        ///将avl、B与C做两次单旋，返回新的根结点C
        ///首先对avl的左子树进行单右旋即RR旋转
        avl->lchild = this->SingleRightRotation(avl->lchild);
        ///然后对avl进行单左旋即LL旋转
        return this->SingleLeftRotation(avl);
    }

    ///右左旋转：RL旋转，右子树的左子树插入导致对的失衡
    AVL* DoubleRightLeftRotation(AVL* avl){
        ///注意：avl必须有一个左子结点B，且B必须有一个右子结点C
        ///将avl、B与C做两次单旋，返回新的根结点C
        ///首先对avl的右子树进行单左旋即LL旋转
        avl->rchild = this->SingleLeftRotation(avl->rchild);
        ///然后对avl进行单右旋即RR旋转
        return this->SingleRightRotation(avl);
    }

    ///获得树的高度
    int getHeight(AVL* avl){
        if(!avl){
            return 0;
        }
        return avl->height;
    }

    ///求两个数的最大值
    int Max(int a,int b){
        return (a>b)?a:b;
    }

    ///递归前序遍历
    void PreorderTraversal(AVL* T){
        if(T == NULL){
            return;
        }
        cout<<T->data<<" ";							//访问根节点并输出
        T->PreorderTraversal(T->lchild);			//递归前序遍历左子树
        T->PreorderTraversal(T->rchild);			//递归前序遍历右子树
    }

    ///递归中序遍历
    void InorderTraversal(AVL* T){
        if(T == NULL){
            return;
        }
        T->InorderTraversal(T->lchild);				//递归中序遍历左子树
        cout<<T->data<<" ";							//访问根节点并输出
        T->InorderTraversal(T->rchild);				//递归中序遍历左子树
    }

    ///递归后序遍历
    void PostorderTraversal(AVL* T){
        if(T == NULL){
            return;
        }
        T->PostorderTraversal(T->lchild);			//递归后序遍历左子树
        T->PostorderTraversal(T->rchild);			//递归后序遍历右子树
        cout<<T->data<<" ";							//访问并打印根节点
    }

    int getdata(AVL* avl){
        return avl->data;
    }
};

int main()
{
    int size;
    cout<<"请输入结点个数："<<endl;
    cin>>size;
    int* data;
    data = new int[size];
    cout<<"请输入每个结点的值："<<endl;
    for(int i = 0 ; i < size ; i++){
        cin>>data[i];
    }
    AVL* avl;
    avl = new AVL;
    avl = avl->Create(data,size);

    cout<<"前序遍历（递归）："<<endl;
    avl->PreorderTraversal(avl);
    cout<<endl;

    cout<<"中序遍历（递归）："<<endl;
    avl->InorderTraversal(avl);
    cout<<endl;

    cout<<"后序遍历（递归）："<<endl;
    avl->PostorderTraversal(avl);
    cout<<endl;

    AVL* avl_max;
    avl_max = avl->FindMax(avl);
    cout<<"二叉搜索树的最大值为："<<endl;
    cout<<avl_max->getdata(avl_max);
    cout<<endl;

    cout<<"二叉搜索树的最小值为："<<endl;
    AVL* avl_min;
    avl_min = avl->FindMin(avl);
    cout<<avl_min->getdata(avl_min);
    cout<<endl;

    int num;
    cout<<"请输入要删除的结点："<<endl;
    cin>>num;
    avl = avl->Delete(avl,num);
    cout<<"删除之后："<<endl;
    cout<<"前序遍历（递归）："<<endl;
    avl->PreorderTraversal(avl);
    cout<<endl;

    cout<<"中序遍历（递归）："<<endl;
    avl->InorderTraversal(avl);
    cout<<endl;

    cout<<"后序遍历（递归）："<<endl;
    avl->PostorderTraversal(avl);
    cout<<endl;

    cout<<"请输入要删除的结点："<<endl;
    cin>>num;
    avl = avl->Delete(avl,num);
    cout<<"删除之后："<<endl;
    cout<<"前序遍历（递归）："<<endl;
    avl->PreorderTraversal(avl);
    cout<<endl;

    cout<<"中序遍历（递归）："<<endl;
    avl->InorderTraversal(avl);
    cout<<endl;

    cout<<"后序遍历（递归）："<<endl;
    avl->PostorderTraversal(avl);
    cout<<endl;

    cout<<"请输入要删除的结点："<<endl;
    cin>>num;
    avl = avl->Delete(avl,num);
    cout<<"删除之后："<<endl;
    cout<<"前序遍历（递归）："<<endl;
    avl->PreorderTraversal(avl);
    cout<<endl;

    cout<<"中序遍历（递归）："<<endl;
    avl->InorderTraversal(avl);
    cout<<endl;

    cout<<"后序遍历（递归）："<<endl;
    avl->PostorderTraversal(avl);
    cout<<endl;

    return 0;
}

我是花花，祝自己也祝您变强了~ 

吕飞雨的头发不能秃
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉排序树与平衡二叉树的实现
qq_39717454的博客
07-03 8548
一、实验目的1、问题描述     分别采用二叉链表和顺序表作存储结构，实现对二叉排序树与平衡 二叉树的操作。2、设计功能要求(1)用二叉链表作存储结构实现二叉排序树。      1)以回车符(‘\n’)为输入结束标志，输入数列L，生成一棵二叉排序 树T；      2)对二叉排序树T作中序遍历，输出结果；      3)计算二叉排序树T查找成功的平均查找长度，输出结果；      4)输入元素x，...
数据结构平衡二叉排序树
02-13
在测试部分，给出了一个具体的测试用例，即输入45, 24, 53, 12, 24, 90, 0，程序会根据这些数据构建一棵平衡的二叉排序树，并输出相应的遍历结果和平衡因子。 总结来说，这个实验涵盖了数据结构中的重要主题，如AVL...
平衡二叉树的C语言实现（创建、插入、查找、删除、旋转）【数据结构】
白纸的专栏
08-10 8727
平衡二叉树(AVL)或者是一颗空树，或者是具有下列性质的非空二叉搜索树： (1). 任一结点的左、右子树均为AVL树； (2). 任一结点的左、右子树高度差的绝对值不超过1。 对于二叉树中任一结点T，其“平衡因子”(Balance Factor, BF)定义为BF(T) = Hl-Hr，其中Hl和Hr分别为T的左、右子树的高度。 有了平衡因子的定义，AVL树“任一结点左右子
平衡二叉树的插入旋转
weixin_34128839的博客
07-13 188
平衡二叉树定义(AVL树) 　平衡二叉树是在二叉排序树(BST)上引入的，就是为了解决二叉排序树的不平衡性，而不平衡性又是时间复杂度增大的主要原因。 　例如：数组a=[12,24,37,45,53,93]建立二叉排序树为下图所示。左图为平衡二叉树，右图为二叉排序树。 　 图1 由上图可知，当你进行查找时，右图的平...
数据结构之构建平衡二叉排序树
郑小小小小源的博客
01-24 1809
本文解决的问题： 随机产生20个树，构建平衡二叉排序树。 实现代码如下： #include #include #define EH 0 /*等高*/ #define LH 1 /*左高*/ #define RH -1 /*右高*/ typedef struct btnode { int data; int BF
平衡二叉搜索树的创建
qq_41891805的博客
03-03 794
平衡二叉搜索树 平衡二叉树：每个结点的左右子树高度差不超过1，左右子树均为平衡二叉树 搜索二叉树：左结点 < 根结点 <右结点 平衡二叉搜索树则是优化后的搜索二叉树，使得查找的效率提升，但是在添加数据时，需要进行复杂的判断，所以一般使用在查找频繁而修改很少的存储结构中。 平衡二叉树的建立 整个建立过程分为三大部分： ①插入新的结点 ②判断插入结点后树是否平衡，并找到不平衡的点 ③若不平...
数据结构课程设计 二叉排序树与平衡二叉排序树
05-29
在数据结构的学习中，二叉排序树（Binary Search Tree，BST）是一种常见的树形数据结构，它具有查找、插入和删除等操作的高效性。在这个课程设计中，我们将重点探讨如何利用二叉链表作为存储结构来实现二叉排序树，...
java 二叉排序树与平衡二叉树的实现
01-10
10. **algorithm**：可能是一个包含各种算法实现的文件夹，如二叉排序树和平衡二叉树的插入、查找和删除算法。 通过这个课程设计，学生将深入理解二叉排序树和平衡二叉树的概念，以及它们在实际问题中的应用，同时...
较全的二叉排序树程序
03-16
在"二叉排序树各种算法汇总"这个主题中，你可以期待看到不同类型的二叉排序树操作的实现，包括但不限于插入、查找、删除等基础操作，以及可能包含的优化策略如平衡调整、迭代和递归的不同实现方式。而关于Win7环境下...
平衡二叉排序树
01-07
**平衡二叉排序树**（Balanced Binary Search Tree，简称BBST）是一种特殊的二叉搜索树，它在保持二叉搜索树特性的同时，通过自平衡机制确保树的高度尽可能小，从而提高查找、插入和删除等操作的效率。在平衡二叉...
平衡二叉树的插入和删除
06-08
自己整了一天写的平衡二叉树的插入和删除,暂时还没发现bug...
数据结构---二叉平衡排序树的删除
qq_43552933的博客
08-27 134
数据结构—二叉平衡排序树的删除 原理：参考趣学数据结构 代码： #include<stdio.h> #include<stdlib.h> typedef struct avlTree { int data; struct avlTree *lchild, *rchild; int height; }avlTree; int height(avlTree* AVLTree);//声明avl树的深度 void updateHeight(avlTree* &AVLTree)
二叉排序树的旋转平衡
qq_31339017的博客
07-06 597
数据结构之平衡树 插入删除操作(包括代码)
蜀沐的博客
07-31 231
1、左旋 左旋：以某个结点作为支点(旋转结点)，其右子结点变为旋转结点的父结点，右子结点的左子结点变为旋转结点的右子结点，左子结点保持不变 2、右旋 右旋：以某个结点作为支点(旋转结点)，其左子结点变为旋转结点的父结点，左子结点的右子结点变为旋转结点的左子结点，右子结点保持不变 #include<iostream> using namespace std; typedef struct BiTNode{ int data; int height; //高度,表示以当前结点为根的子树的高
【树】平衡二叉搜索树的介绍与构建
最新发布
qq_63691275的博客
02-10 1364
平衡二叉树（Balanced Binary Tree）具有以下性质： 1. 要么是空树要么左右两个子树的高度差的绝对值不超过1； 2. 左右子树也都是一棵平衡二叉树； 3. 每个节点都有一个平衡因子（Balanced Factor），任意一个节点的平衡因子的值为 -1、0、1，计算公式是 左子树高度 - 右子树高度。
【算法】二叉排序树：创建二叉树，并以中序遍历输出
软件工程探索之旅
08-19 2848
常见的二叉树： 二叉树定义： 在计算机科学中，二叉树是每个结点最多有两个子树的树结构 demo： 1、创建节点类：Node public class Node { private Node left; // 左子节点 private Node right; // 右子节点 private int data; // 节点的值 public Node(int data){...
♥删除二叉排序树结点的代码实现♥
m0_52711790的博客
10-22 314
对于一个二叉排序树，要删除其某个结点，重点要找到两个关键结点（自身与父结点），代码实现如下： #include<iostream> #include<string> using namespace std; class Node{ public: int value; Node *left,*right; int countt=1; Node(int value){ this->value=value; le
二叉排序树删除结点操作(代码实现) [Java]
m0_57001006的博客
11-20 778
*** 测试方法, 测试我们编写的二叉排序树类中的方法是否是正确的//创建一个二叉排序树类 BinarySortTree binarySortTree = new BinarySortTree();//我们先创建几个结点 Node node1 = new Node(2);//然后调用我们添加结点的方法将我们节点添加到我们的二叉排序树类中 binarySortTree . add(node1);
二叉树删除结点 c语言,平衡二叉树的 插入 删除 查找 等功能c语言实现 数据结构...
weixin_27303545的博客
05-21 170
#include#include #include //左子树比右子树高一#define LH 1//左子树和右子树一样高#define EH 0//左子树比右子树低一#define RH -1#define EQ(a,b) ((a) == (#include#include#include//左子树比右子树高一#define LH 1//左子树和右子树一样高#define EH 0//左子树比右...
构建平衡二叉排序树：插入与旋转策略解析
然而，如果插入的数据顺序不当，二叉排序树可能会变成高度不平衡的状态，导致查找效率降低。为了解决这个问题，我们需要使其成为平衡树，以确保高效的查找性能。 平衡二叉树（Balanced Binary Tree）如AVL树或红黑...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

吕飞雨的头发不能秃

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值