AVL实现 C++

最新推荐文章于 2024-06-27 17:15:47 发布
最新推荐文章于 2024-06-27 17:15:47 发布
阅读量507 收藏
点赞数
文章标签： insert 数据结构 tree reference c++ date
一. AVL概念： 
    对于一颗BST，其中每个节点的左右子树高度差均不超过1的平衡二叉搜索树，就叫做AVL树。 
二. 如何维护一颗AVL树。 
    旋转操作： 
    1. rotateWithLeft:(右旋转) 
*       (N)                (L) 
*      /   \              /   \ 
*    (L)    3    ==>     1    (N)  
*   /   \                    /   \ 
*  1     2                  2     3 
    2. rotateWithRight:(左旋转) 
*    (N)                (R) 
*   /   \              /   \ 
*  1    (R)    ==>   (N)    3 
*      /   \        /   \ 
*     2     3      1     2 

三.AVL的基本操作: 
  1. Find(x,AVL);//在AVL树中查找值为X的元素  
  2. Insert(x,&AVL);//在AVL树中插入值为X的元素  
  3. Remove(x,&AVL);//在AVL树中删除值为X的元素  
  4. FindMax(AVL);//查找AVL树中的最大值  
  5. FindMin(AVL);//查找AVL树中的最小值  
  6. rotateWithLeft(&node);//右旋  
  7. rotateWithRight(&node)//左旋  


四.AVL的静态实现: 
  1.用到的数据结构:int left[],right[],next[],height[],data[]. 
  2.说明: left,right分别保存节点的左子结点和右子结点,0表示空，height保存某一结点的   高度，用来计算平衡因子,data保存结点的数据. 
  3.实现分析: 
    （1）.FindMax,Find,FindMin,和BST的一样。 
    （2）.Insert,将元素插入AVL树后，沿插入路径逆向，从插入位置开始，遇到第一个不平 衡的结点就将该子树旋转至平衡，如此操作，整棵AVL都达到平衡。 
    （3）.Remove,先仿造BST的删除方式进行删除,从删除位置沿删除路径返回根节点，只要遇到不平衡的结点就旋转. 
    （4）.旋转操作，不平衡的点一定有孙子，祖父与孙子共线: 单旋转；祖父与孙子不共线: 双旋转。(图来自刘汝佳的书《高级数据结构》) 
     单旋转： 

     双旋转： 

五.实现代码: 

   #include<iostream>
#include<queue>
#include<vector>
using namespace std;
#define SIZE 100
#define MAX(a,b) a>b?a:b
/**
** author: yfr
** date: 2012-1-9
** project: AVL tree
** reference: LRJ's BOOK
** 用数组模拟链式结构（姑且用静态这个说法）,实现AVL的插入操作 
** 这里不直接用平衡因子，而是保持树各结点的高度，然后去计算平衡因子 
** 空树的高度是-1 
**/
int Left[SIZE],Right[SIZE],next[SIZE],data[SIZE],height[SIZE];
/*辅助容器*/
vector<int> look[SIZE];
int depth[SIZE];
/**/
/**
所有操作申明 
**/
void Init();
int makenode(int x);
void delnode(int);
int find(int x,int p);
int findmin(int);
int findmax(int);
void insert(int x,int &p);
void remove(int x,int &p);

//初始化各数组
void Init()
{
   memset(Left,0,sizeof(Left));
   memset(Right,0,sizeof(Right));
   memset(height,-1,sizeof(height));//空树高度为-1 
   for(int i=0;i<SIZE;i++)
   next[i] = i+1;
}
//模拟内存分配函数  
int makenode(int x)
{
    int p = next[0];
    next[0] = next[p];
    data[p] = x;
    return p;
}
void delnode(int p)
{
    Left[p] = Right[p] = 0;
    height[p] = -1;
    next[p] = next[0];
    next[0] = p;
}
//AVL的操作函数
/*旋转
         a                           b
          \                         / \
           b    ------------>      a   c
          / \                     /
         d   c                   d 
*/
void rotateWithRight(int &p)
{
     int q = Right[p];
     Right[p] = Left[q];
     Left[q] = p;
     height[p] = MAX(height[Left[p]],height[Right[p]])+1;
     height[q] = MAX(height[Right[q]],height[p])+1;
     p = q;//
} 
/*旋转
         a                           b
        /                           / \
       b      ------------->       c   a
      / \                             /
     c   d                           d  
*/
void rotateWithLeft(int &p)
{
    int q = Left[p];
    Left[p] = Right[q];
    Right[q] = p;
    height[p] = MAX(height[Left[p]],height[Right[p]])+1;
    height[q] = MAX(height[Left[q]],height[p])+1;
    p = q;
}
void insert(int x,int &p)
{
    if(!p)
    {
       p = makenode(x);
       height[p] = MAX(height[Left[p]],height[Right[p]])+1;
       return;
    }
    if(x < data[p])
    {
       insert(x,Left[p]);
       height[p] = MAX(height[Left[p]],height[Right[p]])+1;
       if(height[Left[p]]-height[Right[p]]==2)//不平衡 
       {
           if(height[Left[Left[p]]]-height[Right[Left[p]]]==1)//LL
           {
               rotateWithLeft(p);
           }
           else if(height[Left[Left[p]]]-height[Right[Left[p]]]==-1)//LR
           {
               rotateWithRight(Left[p]);
               rotateWithLeft(p);
           }
       }
    }
    else 
    {
       insert(x,Right[p]);
       height[p] = MAX(height[Left[p]],height[Right[p]])+1;
       if(height[Left[p]]-height[Right[p]]==-2)//不平衡
       {
           if(height[Left[Right[p]]]-height[Right[Right[p]]]==1)//RL
           {
               rotateWithLeft(Right[p]);
               rotateWithRight(p);
           }
           else if(height[Left[Right[p]]]-height[Right[Right[p]]]==-1)//RR
           {
               rotateWithRight(p);
           }
       } 
    }
}
//从AVL树中删除节点 
//先删除，再调整树形 
void remove(int x,int &p)
{
     if(!p) return;//如果是空树，返回
     if(x < data[p]){
          remove(x,Left[p]);
     }
     else if(x > data[p]){
          remove(x,Right[p]);
     }
     else//如果已经找到该结点 
     {
         if(Left[p]&&Right[p])//如果左右结点非空
         {
             int q = findmin(Right[p]);
             data[p] = data[q];
             remove(data[p],Right[p]);
         }
         else
         {
             int q = p;
             p = Left[p]?Right[p]:Left[p]; 
             delnode(q);//释放该结点 
             return;//删除处的高度不需要调整 
         } 
     } 
     if(p){//如果不是空树的话 
       height[p] = MAX(height[Left[p]],height[Right[p]])+1;//记录高度
       //不平衡则旋转 
       if(height[Left[p]]-height[Right[p]]==2)//L
       {
          if(height[Left[Left[p]]]-height[Right[Left[p]]]>=0)//L
          {
             rotateWithLeft(p);//LL旋转 
          }
          else//R 
          {
          //LR旋转 
             rotateWithRight(Left[p]);
             rotateWithLeft(p);
          }
       }
       else if(height[Left[p]]-height[Right[p]]==-2)//R
       {
          if(height[Left[Right[p]]]-height[Right[Right[p]]]<=0)//RR
          {
             rotateWithRight(p);
          }
          else
          {
             //RL
             rotateWithLeft(Right[p]);
             rotateWithRight(p);    
          }
       } 
     }
}
int find(int x,int p)
{
    if(!p)return 0;
    if(x == data[p]) return p;
    if(x < data[p]) return find(x,Left[p]);
    if(x > data[p]) return find(x,Right[p]);
}
int findmin(int p)
{
    if(!p)return 0;//空树
    if(!Left[p]) return p;
    else return findmin(Left[p]); 
}
int findmax(int p)
{
    if(p)
    while(Right[p]) p = Right[p];
    return p;
}
/*********************
辅助函数 
**********************/
//标记好各结点的层数，查看树形时要用到 
void dfs(int p,int deep)
{
   if(!p)return;
   depth[p] = deep;
   dfs(Left[p],deep+1);
   dfs(Right[p],deep+1);
}
void order(int p)
{
   if(!p)return;
   order(Left[p]);
   cout<<data[p]<<endl;
   order(Right[p]);
}
//查看树形 
void bfs(int p)
{
   dfs(p,0);
   queue<int> q;
   q.push(p);
   while(!q.empty())
   {
      int v = q.front();
      q.pop();
      if(Left[v])q.push(Left[v]);
      if(Right[v])q.push(Right[v]);
      cout<<data[v]<<endl;
      look[depth[v]].push_back(data[v]);
   }
}
void print_tree(int deep)
{
     for(int i=0;i<=deep;i++)
     {
        for(int j=0;j<look[i].size();j++)
        {
           cout<<look[i][j];
           for(int k=0;k<=deep-i;k++)
           cout<<" ";
        }
        cout<<endl;
     }
}
int main()
{
    freopen("dataout.txt","w",stdout);
    Init();
    int ROOT = 0;
    insert(10,ROOT);//build AVLtree
    insert(11,ROOT);
    insert(12,ROOT);
    insert(13,ROOT);
    insert(14,ROOT);
    remove(10,ROOT);
    bfs(ROOT);
    print_tree(height[ROOT]);
    return 0;
}


memewry
关注
AVL c++实现
12-18
AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个儿子子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log n）。
AVL数的实现（C++）
TANGY的博客
04-23 1774
二叉搜索树虽然可以加快查找效率，但当数据有序或接近有序时，二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1（需要对树中的结点进行调整），即可降低树的高度，从而减少平均搜索长度。 一颗AVL树或是空树，或是具有以下性质的二叉搜索树： 它的左右子树都是AVL数 它的左右子树高度之差（简称...
【C++】——AVL树（详细解读）
最新发布
m0_74092462的博客
06-27 886
对于AVL的定义来说首先我们肯定是模板，然后我们的结构为三叉链，同时我们还需要一个平衡因子去平衡高度//三叉链int _bf;//平衡因子AVLTreeNode(const pair& kv)//构造函数, _kv(kv), _bf(0){}插入位置状态操作在parent的左结点（subL）的左子树（subL）上做了插入元素左左型右旋在parent的左结点（subL）的右子树（subLR）上做了插入元素左右型左右旋在parent的右结点（subR）的。
AVL树 C++ 实现
09-20
平衡二叉树(AVL)的C++实现。 用泛型写的。 IDE为VS2008 好像没别的了~ 就怎么个东西
AVL树( C++)
泡温泉
10-04 382
#include #include using namespace std; struct Node { int val; Node *left = nullptr; Node *right = nullptr; int factor = 0; Node(int i) : val(i) {}; }; class AVLTree { public:
AVL树(c++)
weixin_41009689的博客
05-04 294
最近学习了AVL树，书上讲解的第一遍没怎么看懂，在网上搜到一篇不错的贴子，然后结合自己的理解将知识记录下来以便以后的温习回顾 AVL树简介 AVL树的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL树是最先发明的自平衡二叉查找树（Self-Balancing Binary Search Tree,简称平衡二叉树）。 一棵AVL树有如下必要条件： 条...
AVL树的c++实现
08-03
在C++中实现AVL树，我们可以利用模板类来增强代码的通用性，并通过智能指针如`shared_ptr`来管理内存，避免内存泄漏。 首先，我们需要定义一个AVL树节点结构体，包括节点值、高度、左子树和右子树的指针。由于我们...
AVL树（C++）
11-05
基于 C++实现avl树的学生管理系统基于 可直接运行，代码全自己实现
AVL树(C++版本）
qq_50271250的博客
04-23 1480
前言 AVL是一个高度平衡的二叉搜索树，主要是为了减少查找的次数而降低树的高度。 关于二叉搜索树主要是关于二叉树的左旋和右旋以及无法平衡的四种状态 左旋：主要是右子树的高度过高了，所以要左旋，就是根节点与其右孩子交换一下，此时右孩子当作了根节点了，而之间的根节点就作为右孩子的左孩子，但是之前的右孩子是可能存在它的左子树的，这时就可以把这左子树连接之前根节点的右边作为根节点的右子树 右旋与左旋是对称的，就不再赘述 不平衡的四种状态 LL:即在根节点的左孩子的左子树上添加导致不平衡了，此时需要根节点右旋即可。
AVL树的C++实现（1）
zhapeng1的博客
06-30 237
为什么要AVL 在之前的介绍的二分搜索树中，我们发现它查找、添加、删除元素的复杂度为O(logn)O(logn)O(logn)级别，但是在某些特殊情况下，比如在添加1，2,3,4,5,6时，你期望能够添加完成为左边的树，但是如果按顺序添加就会退化成链表，复杂度变为O(n)O(n)O(n)级别。此时这种二叉树就成为一种不平衡二叉树，而AVL树就是解决这种不平衡二叉树一种方法。 平衡二叉树从字面上理解就是这棵树要尽量的平衡。但是对于平衡有不同的定义，比如之前说的堆，它是一棵完全二叉树，空缺部分只能出现在右下
AVL的代码实现C++‘
qq_51711403的博客
06-01 199
AVL树的代码实现 这里先粘贴代码 给大家的忠告，一定要及时去实现，不然之后再实现要花跟多的时间 /* *平衡二叉树应该有些功能 *插入 删除 查找 *前序遍历 中序遍历 后序遍历 层次遍历 *统计结点数目 */ //代码已经调，写了很久才写出来 // #ifndef _AVLTREE_ #define _AVLTREE_ #include<iostream> #include<vector> #include<queue> #include<ma
AVL树—— C++实现
Mind_V的博客
05-22 657
AVL树的介绍 AVL树的C实现 AVL树节点 AVL树接口 旋转操作核心 1 LL的旋转 2 RR的旋转 3 LR的旋转 4 RL的旋转 完整的实现代码AVL树的介绍二叉查找树的深度越小，那么查找所需要的运算时间越小。一个深度为log(n)的二叉查找树，查找算法的时间复杂度也是log(n)。然而，我们在二叉查找树中已经实现的插入和删除操作并不能让保持log(n)的深度。如果我们按照8，7，6，5，
AVL树的实现——c++
weixin_30376163的博客
10-08 79
一、概念 AVL树是根据它的发明者G.M.Adelson-Velsky和E.M.Landis命名的。它是最先发明的自平衡二叉查找树，也被称为高度平衡树。相比于"二叉查找树"，它的特点是：AVL树中任何节点的两个子树的高度最大差别为1。 AVL树的查找、插入和删除在平均和最坏情况下都是O(logn)。如果在AVL树中插入或删除节点后，使得高度之差大于1。此时，AVL树的平衡状...
AVL树及其实现(C++)
weixin_43886592的博客
12-16 794
一、AVL树简单介绍 在前面二叉搜索树中，我们可以看出它的查找销率非常高，最优可到达O(Log2(N))，但是当数据越接近有序的时候二叉搜索树将退化成一个链表，查找效率就能变成了O(N)，因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis(AVL的由来)发明了AVL树：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中...
C++ AVL树
weixin_53946312的博客
01-27 1224
AVL树底层结构AVL树(高度平衡搜索二叉树)AVL树的插入四种旋转右单旋左单旋右左双旋左右双旋AVL实现代码AVL树的性能 底层结构 map/set/multimap/multiset等这些容器其底层都是按照二叉搜索树来实现的但是二叉搜索树有其自身的缺陷,eg:往树中插入的元素有序或接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N),因此map,set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来来实现。 AVL树(高度平衡搜索二叉树) 二叉搜索树虽然可以缩短查找的效率，但如
AVL C++实现(持续更新)
源码力量
02-04 854
/* * ===================================================================================== * * Filename: avl.cpp * * Description: AVL借鉴Mark Allen Weiss的《数据结构与算法分析C++描述》跟网上 * 一些大牛
C++编程：AVL树的实现与平衡操作
"C++实现AVL树，代码包含AVL树的基本操作，如查找、插入以及平衡调整。" AVL树是一种自平衡二叉搜索树（Self-balancing Binary Search Tree），由G. M. Adelson-Velsky和E. M. Landis在1962年提出，因此得名AVL树。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值