AVL树及其C语言实现

1.AVL树简介

AVL树是带有平衡条件的二叉查找树，这个平衡条件必须容易保持。前面我写过二叉搜索树，然而这个树的最大深度为n，最小深度为logn，因此查找时效率不是特别高，我们可以构建这样一棵树，它的最大深度始终为logn，这就是AVL树，它要求每个节点的左子树和右子树的高度最多差1的二叉查找树。（空树高度定义为-1）

AVL树的平衡必须在每一步操作中都可以保持，在插入以后，只有那些从插入点到根节点的路径上的节点的平衡条件可能会被改变，因为只有这些节点的子树可能发生变化。当我们沿着这条路径上行到根并更新平衡信息时，我们可以找到一个节点，它的新平衡破坏了AVL条件。我们将指出如何在第一个这样的节点重新平衡这棵树，并且满足AVL特性。

2.AVL树的平衡

AVL树的平衡被破坏通常是下面的四种情况，把必须平衡的节点叫做alpha，由于节点最多有两个儿子，因此高度不平衡时，alpha的两颗子树的高度差2：

对alpha的左儿子的左子树进行一次插入；

对alpha的左儿子的右子树进行一次插入；

对alpha的右儿子的左子树进行一次插入；

对alpha的右儿子的右子树进行一次插入；

显然，第一种情况和第四种情况较为简单，只需进行一次单旋转即可：

上图表明，左侧开始超重，导致5的左子树的高度明显比右子树的高度大2，因此这个时候需要进行单旋转，即将3变成根节点，将5变成3的右子树，这样就使得树继续平衡了。对于右侧超重的情况，也可类似分析。

但是，对于第二种和第三种情况，重新平衡就相对复杂一点，如下图所示：

如上图所示，节点5的左子树明显超重，但是4是3的右子树，这样就不能通过简单的单旋转来实现平衡。这里我们需要进行两次单旋转即可，首先对3进行单次右旋转，这样4就成了5的左节点，而3就变成了4的左节点，最后5/3/4的排布就变成了第一种情况，那么就可以对节点5进行单次左旋转即可。最后，4成了1的右节点，3成了4的左节点，5成了4的右节点。如下图所示：

上面就是双旋转。

其他情况可以依次类比。

3.AVL树的C实现

/*
  This is the head file for AVL data structure
*/
#ifndef _AVL_H
#define _AVL_H

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct TreeNode *PtrToNode;
typedef PtrToNode Tree;
typedef PtrToNode Position;
struct TreeNode {
    int Element;
    Tree Left; //节点左孩子
    Tree Right; //节点右孩子
    int Height;
};

int Max(int a,int b);
Position SingleRotateWithLeft(Position K2);
Position SingleRotateWithRight(Position K2);
Position DoubleRotateWithLeft(Position K3);
Position DoubleRotateWithRight(Position K3);
Tree Insert(int X, Tree T);
Position FindMax(Tree T);
Position FindMin(Tree T);
Position Find(int X, Tree T);
Tree MakeEmpty(Tree T);

void PrintWithPreorder(Tree T);
void PrintWithInorder(Tree T);
void PrintWithPostorder(Tree T);
int Height(Position P);

#include "AVL.c"
#endif

然后是AVL.c文件

#include "AVL.h"
/*
* 使二叉树变为空，采用递归释放内存的方法
*/
Tree MakeEmpty(Tree T)
{
    if (T != NULL) {
        MakeEmpty(T->Left);
        MakeEmpty(T->Right);
        T->Height=-1;
        free(T);
    }
    return NULL;
}

/*
* 查找某一元素
*/
Position Find(int X, Tree T)
{
    if (T == NULL) {
        return NULL;
    }
    if (X < T->Element) {
        return Find(X, T->Left);
    }
    else if (X>T->Element) {
        return Find(X, T->Right);
    }
    else {
        return T;
    }
}
/*
* 寻找最小值
*/
Position FindMin(Tree T)
{
    if (T == NULL) {
        return NULL;
    }
    else if (T->Left == NULL) {
        return T;
    }
    else {
        FindMin(T->Left);
    }
}
/*
* 寻找最大值
*/
Position FindMax(Tree T)
{
    if (T == NULL) {
        return NULL;
    }
    else if (T->Right == NULL) {
        return T;
    }
    else {
        FindMax(T->Right);
    }
}
/*
* 插入元素到二叉树中
*/
Tree Insert(int X, Tree T)
{
    if (T == NULL) {
        T = (Tree)malloc(sizeof(struct TreeNode));
        if (T == NULL) {
            printf("Out of memory!\n");
            exit(1);
        }
        else {
            T->Element = X;
            T->Left = T->Right = NULL;
            T->Height=0;
        }
    }
    else if (X < T->Element) {
        T->Left = Insert(X, T->Left);
        if(Height(T->Left)-Height(T->Right)==2) {
            if(X<T->Left->Element)
                T=SingleRotateWithLeft(T);
            else
                T=DoubleRotateWithLeft(T);
        }
    }
    else if (X > T->Element) {
        T->Right = Insert(X, T->Right);
        if(Height(T->Right)-Height(T->Left)==2) {
            if(X>T->Right->Element)
                T=SingleRotateWithRight(T);
            else
                T=DoubleRotateWithRight(T);
        }
    }
    T->Height=Max(Height(T->Left),Height(T->Right))+1;
    return T;
}

Position SingleRotateWithLeft(Position K2)
{
    Position K1;
    K1=K2->Left;
    K2->Left=K1->Right;
    K1->Right=K2;
    K2->Height=Max(Height(K2->Left),Height(K2->Right))+1;
    K1->Height=Max(Height(K1->Left),K2->Height)+1;
    return K1;
}

Position SingleRotateWithRight(Position K2)
{
    Position K1;
    K1=K2->Right;
    K2->Right=K1->Left;
    K1->Left=K2;
    K2->Height=Max(Height(K2->Left),Height(K2->Right))+1;
    K1->Height=Max(Height(K1->Right),K2->Height)+1;
    return K1;
}

Position DoubleRotateWithLeft(Position K3)
{
    K3->Left=SingleRotateWithRight(K3->Left);
    return SingleRotateWithLeft(K3);
}

Position DoubleRotateWithRight(Position K3)
{
    K3->Right=SingleRotateWithLeft(K3->Right);
    return SingleRotateWithRight(K3);
}

int Max(int a,int b)
{
    return (a>b)?a:b;
}

/*
* 前序遍历打印所有元素
*/
void PrintWithPreorder(Tree T)
{
    if (T != NULL) {
        printf("%d\t", T->Element);
        PrintWithPreorder(T->Left);
        PrintWithPreorder(T->Right);
    }
}
/*
* 中序遍历打印所有元素
*/
void PrintWithInorder(Tree T)
{
    if (T != NULL) {
        PrintWithInorder(T->Left);
        printf("%d\t", T->Element);
        PrintWithInorder(T->Right);
    }
}
/*
* 后序遍历打印所有元素
*/
void PrintWithPostorder(Tree T)
{
    if (T != NULL) {
        PrintWithPostorder(T->Left);
        PrintWithPostorder(T->Right);
        printf("%d\t", T->Element);
    }
}

/*
* 返回节点的高度
*/
int Height(Position P)
{
    if(P == NULL)
        return -1;
    else
        return P->Height;
}

main.c文件：

#include "AVL.h"
int main()
{
    Tree T = NULL;
    T = Insert(3, T);
    T = Insert(2, T);
    T = Insert(1, T);
    T = Insert(4, T);
    T = Insert(5, T);
    T = Insert(6, T);
    T = Insert(7, T);
    T = Insert(16, T);
    T = Insert(15, T);
    T = Insert(14, T);
    printf("Min is %d\n", FindMin(T)->Element);
    printf("Max is %d\n", FindMax(T)->Element);
    //下面采用中序遍历方式打印所有节点元素
    PrintWithPreorder(T);
    printf("\n");
    return 0;
}
时间： 2025-01-08 14:23:02

AVL树及其C语言实现的相关文章

AVL树，C语言实现，完整代码，先贴上，讲解稍后

#include<stdio.h>#include<stdlib.h>#include<string.h>#include<time.h>#define ADD_FOUND 0#define ADD_ALLOC_FAILED 1#define ADD_ROOT 2#define ADD_NORMAL 3#define ADD_RLNULL 4#define ADD_LRNULL 5#define DEL_LLNULL 6#define DEL_LRNULL

AVL树原理及实现（C语言实现以及Java语言实现）

欢迎探讨,如有错误敬请指正 如需转载,请注明出处http://www.cnblogs.com/nullzx/ 1. AVL定义 AVL树是一种改进版的搜索二叉树.对于一般的搜索二叉树而言,如果数据恰好是按照从小到大的顺序或者从大到小的顺序插入的,那么搜索二叉树就对退化成链表,这个时候查找,插入和删除的时间都会上升到O(n),而这对于海量数据而言,是我们无法忍受的.即使是一颗由完全随机的数据构造成的搜索二叉树,从统计角度去分析,在进行若甘次的插入和删除操作,这个搜索二叉树的高度也不能令人满意.这个

[转载]AVL树(一)之 图文解析 和 C语言的实现

概要 本章介绍AVL树.和前面介绍"二叉查找树"的流程一样,本章先对AVL树的理论知识进行简单介绍,然后给出C语言的实现.本篇实现的二叉查找树是C语言版的,后面章节再分别给出C++和Java版本的实现. 建议:若您对"二叉查找树"不熟悉,建议先学完"二叉查找树"再来学习AVL树. 目录 1. AVL树的介绍 2. AVL树的C实现3. AVL树的C实现(完整源码) 4. AVL树的C测试程序 转载请注明出处:http://www.cnblogs.

《数据结构与算法分析：C语言描述》复习——第四章“树”——AVL树

2014.06.15 16:22 简介: AVL树是一种高度平衡的二叉搜索树,其命名源自于联合发明算法的三位科学家的名字的首字母.此处“平衡”的定义是:任意节点的左右子树的高度相差不超过1.有了这个平衡的性质,使得AVL树的高度H总是接近log(N),因此各种增删改查的操作的复杂度能够保证在对数级别.没有bad case是AVL树与普通的二叉搜索树的最大区别.为了实现平衡性质,我们需要记录每个节点的高度(或者平衡因子)来检测不平衡的情况.为了修正高度不平衡,需要用到“旋转”的方法,分为单旋转和双

数据结构之AVL树

说明:本文仅供学习交流,转载请标明出处,欢迎转载! 在前面的博文中,我们已经介绍了数据结构之二分查找树的相关知识,二分查找的提出主要是为了提高数据的查找效率.同一个元素集合可以对应不同的二分查找树BST,二分查找树的形态依赖于元素的插入顺序.同时我们也已经知道,如果将一个有序的数据集依次插入到二查找树中,此时二分查找树将退化为线性表,此时查找的时间复杂度为o(n).为了防止这一问题的出现,便有了平衡二叉树的存在价值.平衡二叉树从根本上将是为了防止出现斜二叉树的出现,从而进一步提高元素的查找效率,

一步一步写平衡二叉树（AVL树）

平衡二叉树(Balanced Binary Tree)是二叉查找树的一个进化体,也是第一个引入平衡概念的二叉树.1962年,G.M. Adelson-Velsky 和 E.M. Landis发明了这棵树,所以它又叫AVL树.平衡二叉树要求对于每一个节点来说,它的左右子树的高度之差不能超过1,如果插入或者删除一个节点使得高度之差大于1,就要进行节点之间的旋转,将二叉树重新维持在一个平衡状态.这个方案很好的解决了二叉查找树退化成链表的问题,把插入,查找,删除的时间复杂度最好情况和最坏情况都维持在O(

AVL树的插入与删除

AVL 树要在插入和删除结点后保持平衡,旋转操作必不可少.关键是理解什么时候应该左旋.右旋和双旋.在Youtube上看到一位老师的视频对这个概念讲解得非常清楚,再结合算法书和网络的博文,记录如下. 1.1 AVL 的旋转 一棵AVL树是其每个节点的左子树和右子树的高度差最多为1的二叉查找树(空树高度定义为-1).AVL树插入和删除时都可能破坏AVL的特性,可以通过对树进行修正来保证特性,修正方法称为旋转. 下面以4个插入操作为例,说明不同旋转对应的场景. 1.1.1 LL-R 插入结点为6,沿着

二叉树之AVL树的平衡实现(递归与非递归)

这篇文章用来复习AVL的平衡操作,分别会介绍其旋转操作的递归与非递归实现,但是最终带有插入示例的版本会以递归呈现. 下面这张图绘制了需要旋转操作的8种情况.(我要给做这张图的兄弟一个赞)后面会给出这八种情况对应平衡实现. [1] 情况1-2: 这种需要旋转的结构一般称之为LL型,需要右旋 (顺时针旋转). 我用一个图来抽象一下这两个情况,画的不好,我尽量表达吧. 此时需要对A进行平衡操作,方法为: 将A的左子树换为B的右子树. B的右子树换为A. 非递归实现的代码为: 1 void rotate

数据结构与算法简记：AVL树

前面记录了二叉查找树,它在搜索方面的效率显而易见,可它也存在某种缺陷,假设我们连续插入较小或较大的数据,那么二叉查找树将会逐渐退变为一个线性结构,从而搜索就变为了线性查找,效率将会大打折扣.所以,我们需要一棵这样的树,它在插入新节点后,能够重新调整自己的结构,使左右恢复平衡.AVL树就符合这个条件. AVL树是最先发明的自平衡二叉查找树,其得名于它的发明者 G.M. Adelson-Velsky 和 E.M. Landis,他们在 1962 年的论文 "An algorithm for the