AVL树递归实现

最新推荐文章于 2023-05-01 17:06:42 发布
最新推荐文章于 2023-05-01 17:06:42 发布
阅读量682 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： C/C++算法 文章标签： tree null delete insert list struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/d1x2p3/article/details/6668972
本文介绍了一种使用递归方式实现AVL树的方法，并通过C++代码示例展示了如何进行节点插入、旋转调整及遍历等操作。文章还讨论了递归与非递归实现的效率差异。

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

AVL树递归实现


递归在算法上比较容易实现，但是由于函数调用要额外开辟和释放系统栈空间，所以效率没有非递归方式高，但是非递归方式实现起来比较困难。

如果对大量数据建立AVL树，且要求查找效率的话，还是用非递归方式---循环。

说明：程序运行后，列出节点元素前的“=”符号表示节点的深度。“*”表示该节点是根节点。


//============================================================================
// Name        : AVL_BTree.cpp
// Author      : dxp
// Version     : 1.0
// Copyright   : hpu
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
using namespace std;


class AVL_Tree
{
    typedef int KEY;
private:
    struct TNode
    {
      
        TNode *	left;
        TNode * right;
        int height;
        KEY  key;

    };

    TNode * Troot;

public:

    AVL_Tree();
    void Del_tree();
    void Del_tree_elem(TNode*&);
    void SingleLeft_Rotate(TNode * &);
    void SingleRight_Rotate(TNode * &);
    void DoubleLeft_Rotate(TNode * &);
    void DoubleRight_Rotate(TNode * &);
    void Visit(TNode *,int);
    void Visit_elem( TNode * ,int);
    void MakeEmpty();
    void Find_elem(KEY,TNode * &,TNode*&);
    void Insert_elem(KEY,TNode* &);
    void Delete_elem(KEY , TNode *&);
    void Delete(KEY);
    TNode* Findmax_elem(TNode *);
    TNode* Findmin_elem(TNode *);
    void FindMin();
    void FindMax();
    void List();
    void Insert(KEY);
    int GetHeight(TNode* &);
    int MAX_height(TNode* &);
    void Find(KEY);
    TNode* Getroot()
    {
        return Troot;
    }



    ~AVL_Tree()
    {
        Del_tree();

    }


};

#define SINGLE_LEFT

int main()
{
    AVL_Tree tree;
    for (int i=1;i<=100;i++)
        tree.Insert(i);

    tree.List();
  
	tree.Find(56);
    tree.FindMin();
    tree.FindMax();
  
    return 0;
}




AVL_Tree::AVL_Tree()
{

    Troot=NULL;

}

int AVL_Tree:: MAX_height(TNode* & root)

{

    if (GetHeight(root->left)>GetHeight( root->right))
        return GetHeight(root->left);
    else
        return GetHeight(root->right);
}

void AVL_Tree::SingleLeft_Rotate(TNode * & root)
{

    TNode* tmp=root->left;

    root->left=tmp->right;
    tmp->right=root;
    root=tmp;


    root->right->height=MAX_height(root->right)+1;
    root->height=MAX_height(root)+1;


}

void AVL_Tree::SingleRight_Rotate(TNode * & root)
{
    TNode* tmp=root->right;

    root->right=tmp->left;
    tmp->left=root;
    root=tmp;

    root->left->height=MAX_height(root->left)+1;
    root->height=MAX_height(root)+1;



}

void AVL_Tree::DoubleLeft_Rotate(TNode *& root)
{

    SingleRight_Rotate(root->left);
    SingleLeft_Rotate(root);

}
void AVL_Tree::DoubleRight_Rotate(TNode *& root)
{




}
int AVL_Tree::GetHeight(TNode * &root)
{

    if (root==NULL)	 return -1;
    else return root->height;
}

void AVL_Tree::Insert_elem(KEY Ckey,TNode* & root)
{
    if (root==NULL)
    {

        root=new TNode;
        if (root==NULL)
        {

            cout<<"have no memory to used!"<<endl;
            exit(1);
        }
        else
        {
            root->left=NULL;
            root->right=NULL;
            root->height=0;
            root->key=Ckey;
        }

    }

    else
        if (Ckey< root->key)

        {
            AVL_Tree::Insert_elem(Ckey,root->left);

#ifdef SINGLE_LEFT
            if (GetHeight(root->left) - GetHeight(root->right)==2)
                if (Ckey<root->left->key)
                    SingleLeft_Rotate(root);
                else
                    DoubleLeft_Rotate(root);
#endif
        }

        else
            if (root->key<Ckey)
            {
                AVL_Tree::Insert_elem(Ckey,root->right);

                if (GetHeight(root->left) - GetHeight(root->right)==-2)
                    if (Ckey > root->right->key)
                        SingleRight_Rotate(root);
                    else
                        DoubleRight_Rotate(root);


            }

    root->height=MAX_height(root)+1;

}


void AVL_Tree:: Visit_elem(TNode* cp,int lay)
{
    if (cp!=NULL)
    {
        if (lay==1) printf("*");
        else
            printf(" ");
        for (int i=0;i<lay;i++)
            printf("=");

        printf(" %2d:%d\n", cp->key,cp->height);
    }
}
void AVL_Tree::Visit(TNode* p,int i)
{
    i++;
    if (p==NULL)
    {

        return;
    }
    Visit_elem(p,i);

    AVL_Tree::Visit(p->left,i);

    AVL_Tree::Visit(p->right,i);

}
void AVL_Tree::List()
{
    if (Troot==NULL)
        cout<<"List failed: the AVL_tree not exist!"<<endl;
    Visit(Troot,0);
}
void AVL_Tree::Insert(KEY key)
{
    AVL_Tree::Insert_elem(key,Troot);

}



void  AVL_Tree::Find_elem(KEY Ckey,TNode* &root,TNode* & P_key)
{

    if (root==NULL)
    {
        return ;
    }
    if (root->key == Ckey)
    {
        P_key= root;
        return ;
    }
    AVL_Tree::Find_elem(Ckey,root->left,P_key);

    AVL_Tree::Find_elem(Ckey,root->right,P_key);


}
void AVL_Tree::Find(KEY Ckey)
{
    TNode * p=NULL;
    AVL_Tree::Find_elem(Ckey,Troot,p);
    if (p!=NULL)

        cout<<"Find the element: "<< p->key<<":"<<p->height<<endl;

    else
    {

        cout<<"Find failed: Can't find the element: " <<Ckey<<endl;

    }
}
AVL_Tree::TNode* AVL_Tree::Findmin_elem(TNode *root)
{
    if (root==NULL) return NULL;
    while (root->left)
    {
        root=root->left;

    }
    return root;
}
void AVL_Tree::FindMin()
{
    TNode * p=AVL_Tree::Findmin_elem(Troot);
    if (p==NULL)
        cout<<"this is the min element!"<<endl;
    else
        cout<<"the min element is: "<<p->key<<endl;

}

AVL_Tree::TNode* AVL_Tree::Findmax_elem(TNode *root)
{

    while (root->right)
    {
        root=root->right;

    }
    return root;
}
void AVL_Tree::FindMax()
{
    TNode * p=AVL_Tree::Findmax_elem(Troot);
    if (p==NULL)
        cout<<"this is the max element!"<<endl;
    else
        cout<<"the max element is: "<<p->key<<endl;

}


void AVL_Tree::Delete_elem( KEY Ckey,TNode *& root)
{

    if (root==NULL)
    {
//	cout<<"can't find the element: "<<endl;
        return;
    }
    else
    {
        if (Ckey< root->key) AVL_Tree:: Delete_elem(Ckey,root->left);
        else if (Ckey > root->key ) AVL_Tree::Delete_elem(Ckey, root->right);

        else
        {
            if (root->left && root->right)
            {
                TNode * P_min=Findmin_elem(root->right);
                root->key=P_min->key;
                AVL_Tree::Delete_elem(Ckey,root->right);
            }
            else
            {
                TNode*	tmp=root;
                if (root->left==NULL) root=root->right;
                else if (root->right==NULL) root=root->left;
                delete tmp;

            }
        }
    }
}

void AVL_Tree::Delete(KEY Ckey)
{
    TNode * P_key=NULL;
    AVL_Tree::Find_elem(Ckey,Troot,P_key);
    if (P_key==NULL)
        cout<<"Delete faild: Can't find the element: "<<Ckey<<endl;
    else AVL_Tree::Delete_elem(Ckey,Troot);

}
void AVL_Tree::Del_tree_elem(TNode*& root)
{

    if (root==NULL)
        return ;
    AVL_Tree::Del_tree_elem(root->right);
    AVL_Tree::Del_tree_elem(root->left);
    delete 	root;
    root=NULL;

}


void AVL_Tree::Del_tree()
{

    AVL_Tree::Del_tree_elem(Troot);

}

AVL树的插入与删除(均为递归实现)
ytang007的博客
09-21 3075
AVL树是带有平衡条件的二叉查找树.这个平衡条件必须要容易保持,而且它必须保证树的深度是O(lonN).一颗AVL树是其每个节点的左子树和右子树的高度最多差一的二叉查找树. 主要介绍插入算法和删除算法.
递归实现Avl树的删除、建立（C++）
z_Layman的博客
07-29 564
通过递归实现Avl树的删除和建立(c++)，如有不足之处望指出。 其中avl树的建立参考了《数据结构与算法分析》（C语言实现）。 现附上头文件和删除部分： #ifdef AvlNode #define AviNode struct AvlNode; typedef AvlNode *Position; typedef AvlNode *AvlTree; typedef int Element
AVL树的Java实现（递归方法）
火星日立的博客
12-18 684
AVL树是一种自平衡的二叉查找树。首先它是一种二叉查找树，满足任意一个节点(叶子节点除外)的值大于它左子树上任意一个节点，且小于它右子树上任意一个节点。因为二叉查找树的深度可能为O(N)，这样的效率较低，因此衍生出了AVL树，它具有自平衡的效果，能保持树的深度为O(logN)。AVL树满足：任意一个节点它的左子树的高度和右子树的高度差不超过1。（假设叶子节点的高度为0，null节点的高度为-1）
学习随记三十三——递归实现AVL树
qq_53271740的博客
04-21 242
递归实现AVL树 什么是AVL树： AVL树是一种自调整树，在每次插入和删除后如果平衡被破坏了就会进行自我调整达到重新平衡，AVL树是一种特殊的二叉查找树，它允许左右子树高度最多相差一，当树的平衡遭到破坏时通过单、双旋转重新达到平衡，实现AVl树的关键在于插入，每次插入后要判断树是否平衡。 结点声明： typedef struct Avlnode{ ElementType data=0; struct Avlnode* Left=nullptr; struct Avlnode* Right=nullp
一步一步写平衡二叉树（AVL树）
weixin_30588907的博客
08-20 638
一步一步写平衡二叉树（AVL树） 作者：C小加 更新时间：2012-8-20 　　平衡二叉树（Balanced Binary Tree）是二叉查找树的一个进化体，也是第一个引入平衡概念的二叉树。1962年，G.M. Adelson-Velsky 和 E.M. Landis发明了这棵树，所以它又叫AVL树。平衡二叉树要求对于每一个节点来说，它的左右子树的高度之差不能超过1，如果插入或者删除一个节...
AVL树的非递归实现（Java版）
weixin_42848084的博客
01-30 1233
AVL树的非递归实现（Java版） AVL树是一种二叉查找树的改进算法，它避免了普通二叉树可能出现的长链现象，其根本的算法思想是每当对树进行插入和删除操作时，通过有限的指针变换，改变原有的树的结构，使得每个节点的左子树和右子树相对平衡。 虽然现实中AVL树算法被许多更优秀的算法所替代，但是这一套算法非常适合初学者进行练习，详细的AVL树的教程和博客不难找到。通常，AVL树是通过递归方式来实现的，这...
C++-AVL树的实现
最新发布
05-23
整体而言，C++实现AVL树需要对树的结构和操作有深入的理解，结合递归或迭代的方法以及对平衡因子的调整，来保证树的高效性能。通过不断的实践和优化，可以在各种场景下有效地利用AVL树解决实际问题。
【数据结构】AVL树的非递归实现及AVL树排序
qq_47504614的博客
08-09 334
实验指导 1. 基于二叉链式存储结构实现平衡二叉查找树的典型操作（构造、拷贝构造、析构、赋值运算符重载、节点个数、树高、树宽、增加节点、删除节点、查找一个节点、判空、修改某个节点非关键字部分的数据、先根遍历、后根遍历、中根遍历、按层次遍历），测试和调试程序。 2. 使用平衡二叉查找树完成“树排序”算法，测试和调试程序。“树排序”算法需要使用二叉查找树。我们这里使用平衡二叉查找树完成。完成后运行测试程序检验功能是否正确。 3. 按要求撰写实验报告、录制程序运...
AVL树的C语言实现
11-30
在C语言中实现AVL树，首先需要定义AVL树的节点结构。每个节点包含三个部分：存储数据的关键字（key）、节点的高度（height）以及指向左子树和右子树的指针。一个简单的节点定义如下： ```c typedef struct AVLNode ...
非递归实现AVL树与线性表操作
"该资源是针对非线性数据结构，特别是AVL树的非递归实现的实验指导，包括线性表的双链表实现、树排序和银行账户管理系统的应用。实验旨在帮助在校大学生掌握数据结构的核心概念，并通过C++编程实践来提升技能。实验...
递归建立平衡二叉树（avl）
weixin_33938733的博客
03-13 194
public class avlTest { public static void main(String[] args) { // TODO Auto-generated method stub ControllAvl controller=new ControllAvl(); int []a=new int[]{4,3,5,1,7,8,6,2,9}; for(int i=0;i&l...
avl
chivalry
09-08 1170
http://www.cnblogs.com/heqile/archive/2011/11/28/2265713.html http://dongxicheng.org/structure/avl/ 看完了《数据结构与算法分析(C++描述)》的4.4节AVL树,做一个总结,整理一下自己实现删除算法的思路.(注:本文中图片均来自《数据结构与算法分析(C++描述)》)     A
【AVL树】图解四种旋转/递归求树高/插入节点调整AVL树C语言实现
Ms.Lyq的博客
07-04 1257
不平衡的二叉树四种类型： 对应的四种调整方式： LL：LL失去平衡的情况下，可以通过一次旋转让AVL树恢复平衡。步骤如下： 1.将根节点的左孩子作为新根节点。 2.将新根节点的右孩子作为原根节点的左孩子。 3.将原根节点作为新根节点的右孩子。 RR：RR失去平衡的情况下，旋转方法与LL旋转对称，步骤如下： 将根节点的右孩子作为新根节点。 将新根节点的左孩子作为原根节点的右孩子。 将原根节点作为新根节点的左孩子。 LR：LR失去平衡的情况下，需要进行两次旋转，步骤如下： 1.对根节点的左孩子进行RR旋
AVL -- 平衡二叉树（递归、非递归操作）
m0_65213200的博客
09-02 436
平衡二叉树（递归、非递归操作）
AVL树的原理和代码实现（图文并茂）
qq_56166591的博客
05-01 418
重点讲解AVL树的实现原理和代码
平衡二叉树（AVL）的实现(详细) c++ 二叉排序树
Tree_sea的博客
07-31 3465
平衡二叉树概念 平衡二叉排序树（Balanced Binary Tree），因由前苏联数学家Adelson-Velskii 和 Landis于1962年首先提出的，所以又称为AVL树。 平衡二叉树是一种特殊的二叉排序树，理解平衡二叉树首先要理解什么是二叉排序树。 如果已经了解二叉排序树可以直接看下面平衡二叉树内容。 二叉排序树（Binary Sort Tree） 所谓二叉排序树(BST)即： （1）若该树的左子树不为空，那么左子树所以结点的值均小于其根结点的值。 （2）若该树的右子树不为空，那么右子树所
平衡二叉树AVL的实现（递归及非递归）
屁屁屁喏漕
11-27 650
转载于https://www.cnblogs.com/leihui/p/6002418.html 这篇文章用来复习AVL的平衡操作，分别会介绍其旋转操作的递归与非递归实现，但是最终带有插入示例的版本会以递归呈现。 下面这张图绘制了需要旋转操作的8种情况。（我要给做这张图的兄弟一个赞）后面会给出这八种情况对应平衡实现。   [1]   情况1-2： 　　这种需要旋转的结构一般称之为...
DSA 经典数据结构与算法 学习心得和知识总结(四) | AVL树
孤傲小二~阿沐的博客
09-13 1414
AVL树
AVL树的详细实现(C++)
code_peak
10-05 5608
AVL树概念 前面已经介绍了二叉搜索树，但是二叉搜索树在某些情况下会出现极度不平衡，其树形结构便退化成了链表，查找效率也会下降。于是出现了 AVL 树，AVL 树保证了二叉搜索树的平衡，引入了平衡监督机制，也就是在插入结点时，树中某一部分不平衡度超过一个阈值后将出发平衡调整操作，这样便保证了树的平衡度在可接受的范围内，最大的好处就是提高了搜索的效率。 AVL 树是一种平衡二叉树，其名字来源于发明者的名字（Adelson-Velskii 以及 Landis）。AVL树的递归定义如下： 左右子树的高度差小于等
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值