AVL树

最新推荐文章于 2015-07-26 18:44:22 发布
最新推荐文章于 2015-07-26 18:44:22 发布
阅读量549 收藏
点赞数
分类专栏： 算法学习 文章标签： AVL树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yiluoyan/article/details/45697943
版权

AVL树

AVL树是带有平衡条件的二叉查找树，最简单的定义为：一颗AVL树是其每个节点的左子树和右子树的高度最多相差1的二叉查找树。

C语言定义：

struct AvlNode;
typedef struct AvlNode *position;
typedef struct AvlNode *avlTree;
typedef int  elementType;

struct AvlNode
{
    elementType Element;
    avlTree Left;
    avlTree Right;
    int Height;
};

破坏平衡的四种情况

在对AVL树进行删除或插入操作时，会破坏原来树的平衡，需要进行重新的平衡调整。出现不平衡的情况主要有以下四种：

（1） 对K节点的左儿子的左子树进行一次插入。
LL：LeftLeft，也称为”左左”。插入或删除一个节点后，根节点的左子树的左子树还有非空子节点，导致”根的左子树的高度”比”根的右子树的高度”大2，导致AVL树失去了平衡。

（2）对K节点的左儿子的右子树进行一次插入。
LR：LeftRight，也称为”左右”。插入或删除一个节点后，根节点的左子树的右子树还有非空子节点，导致”根的左子树的高度”比”根的右子树的高度”大2，导致AVL树失去了平衡。

（3） 对K节点的右儿子的左子树进行一次插入。
RL：RightLeft，称为”右左”。插入或删除一个节点后，根节点的右子树的左子树还有非空子节点，导致”根的右子树的高度”比”根的左子树的高度”大2，导致AVL树失去了平衡。

（4）对K节点的右儿子的右子树进行一次插入。
RR：RightRight，称为”右右”。插入或删除一个节点后，根节点的右子树的右子树还有非空子节点，导致”根的右子树的高度”比”根的左子树的高度”大2，导致AVL树失去了平衡。

情形1、4是节点K的镜像对称，2、3是K节点的镜像对称。

这里写图片描述

LL旋转

这里写图片描述

对于LL旋转，你可以这样理解为：LL旋转是围绕”失去平衡的AVL根节点”进行的，也就是节点k2；而且由于是LL情况，即左左情况，就用手抓着”左孩子，即k1”使劲摇。将k1变成根节点，k2变成k1的右子树，”k1的右子树”变成”k2的左子树”。

static position LLrotation(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; // new root
}

RR旋转

RR旋转与LL旋转类似，都是在外边通过删除或插入使得其左右子树高度不平衡。LL与RR时镜像对称的。

这里写图片描述

static position RRrotation(position K2)
{
    position K1;
    K1 = K2 ->Right;
    K2->Right = K1->Left;
    K1 ->Left = K2;

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

LR旋转

第一次旋转是围绕”k1”进行的”RR旋转”，第二次是围绕”k3”进行的”LL旋转”。

这里写图片描述

static position LRrotation(position K3)
{
    K3->Left = RRrotation(K3->Left);

    return LLrotation(K3);
}

RL旋转

RL是与LR的对称情况！RL恢复平衡的旋转方法如下：

这里写图片描述

static position RLrotation(position K1)
{
    K3->Right =LLrotation(K1->Right);

    return RRrotation(K1);
}

AVL树的基本操作

avlTree makeempty(avlTree T);
position Find(elementType x, avlTree T);
void preorder_avltree(avlTree T);//前序遍历树
void inorder_avltree(avlTree T); //中序遍历
void posterorder_avltree(avlTree T); //后续遍历
position findMax(avlTree T);
position findMin(avlTree T);
avlTree Insert(elementType x, avlTree T); //插入元素
avlTree Delete(elementType x, avlTree T); //删除元素
static int Height(position P);

具体实现：

position Find(elementType x, avlTree T)
{
    if (T == NULL)
    {
        printf("tree is empty!\n");
        return NULL;
    }
    if(x < T->Element)
        Find(x, T->Left);
    else 
        Find(x, T->Right);
    return T;
}

avlTree makeempty(avlTree T)
{
    if (T == NULL)
    {
        printf("tree is already empty!\n");
        return NULL;
    }
    if (T->Left == NULL && T->Right == NULL)
    {
        free(T);
    }
    if(T->Left == NULL && T->Right != NULL) 
    {
        makeempty(T->Right);
    }

    if(T->Right == NULL && T->Left != NULL) 
    {
        makeempty(T->Left);
    }

    return T;

}

position findMax(avlTree T)
{
    if (T == NULL)
    {
        printf("tree is empty!\n");
        return NULL;
    }
    while (T->Right != NULL)
        T = findMax(T->Right);
    return T;
}

position findMin(avlTree T)
{

    if (T == NULL)
    {
        printf("tree is empty!\n");
        return NULL;
    }
    while (T->Left != NULL)
        T = findMin(T->Left);
    return T;   
}

avlTree Delete(elementType x, avlTree T)
{
    if (T == NULL)
    {
        printf("tree is empty!\n");
        return NULL;
    }
    if (x < T->Element)  //待删除节点在左子树
    {
        T->Left = Delete(x, T->Left);

        //删除节点后，若树失去平衡，则进行相应的调整
        if (Height(T->Right) - Height(T->Left) == 2)  //节点的右子树比左子树高
        {
            if(Height(T->Right->Right) > Height(T->Right->Left))
                RLrotation(T);
            else 
                RRrotation(T);
        }
    }

    else if (x > T->Element) //删除节点在右子树
    {
        T ->Right = Delete(x,T->Right);
        if (Height(T->Left) - Height(T->Right) == 2)
        {
            if(Height(T->Left->Left) > Height(T->Left->Right))
                LRrotation(T->Left);
            else
                LLrotation(T->Left);
        }
    }
    else  //T是对应要删除的节点
    {
        //节点的左右孩子非空
        if (T->Left &&T->Right)
        {
            if (Height(T->Left) > Height(T->Right))
            {
                //如果T的左子树比右子树高，则找出T的左子树中的最大节点
                //将该节点的值赋给T，删除最大节点
                //即用T的左子树的最大节点做T的替身
                position max = findMax(T->Left);
                T->Element = max->Element;
                T->Left = Delete(max->Element, T->Left);
            }
            else
            {
                //如果T的左子树不比右子树高（即它们相等或者右子树比左子树高
                //则找出T的右子树的最小节点，将该节点的值赋给T，删除最小节点
                //即用T的右子树最小节点替换T
                position min = findMin(T->Right);
                T->Element = min->Element;
                T->Right = Delete(min->Element, T->Right);
            }
        }
        else
        {
            position p = T;
            T = T->Left ? T->Left : T->Right;
            free(p);
        }
    }
    return T;
}


void preorder_avltree(avlTree T) //前序遍历树
{
    if (T != NULL)
    {


        printf("%d  ", T->Element);
        preorder_avltree(T->Left);
        preorder_avltree(T->Right);
    }
}

void inorder_avltree(avlTree T) //中序遍历
{
    if(T != NULL)
    {
        inorder_avltree(T->Left);
        printf("%d  ", T->Element);
        inorder_avltree(T->Right);
    }
}


void posterorder_avltree(avlTree T) //后续遍历
{
    if (T != NULL)
    {
        posterorder_avltree(T->Left);
        posterorder_avltree(T->Right);
        printf("%d  ", T->Element);
    }
}

测试范例

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


struct AvlNode;
typedef struct AvlNode *position;
typedef struct AvlNode *avlTree;
typedef int  elementType;

struct AvlNode
{
    elementType Element;
    avlTree Left;
    avlTree Right;
    int Height;
};


avlTree makeempty(avlTree T);
position Find(elementType x, avlTree T);
void preorder_avltree(avlTree T);//前序遍历树
void inorder_avltree(avlTree T); //中序遍历
void posterorder_avltree(avlTree T); //后续遍历
position findMax(avlTree T);
position findMin(avlTree T);
avlTree Insert(elementType x, avlTree T);
avlTree Delete(elementType x, avlTree T);
static int Height(position P);

static position LLrotation(position K2);
static position LRrotation(position K3);
static position RRrotation(position K2);
static position RLrotation(position K3);

static int Max(int a, int b);

int main()
{
    int a[16] = {3,2,1,4,5,6,7,16,15,14,13,12,11,10,8,9};
    avlTree tree = NULL;

    for (int i = 0; i < 16; i++)
    {
        printf("%d  ",a[i] );
        tree = Insert(a[i], tree);
    }
    printf("\n");

    printf("前序遍历：\n");
    preorder_avltree(tree);

    printf("\n中序遍历： \n");
    inorder_avltree(tree);

    printf("\n后序遍历： \n");
    posterorder_avltree(tree);

    printf("\n树的高度为：%d\n", Height(tree));

    position max = findMax(tree);
    printf("最大值：%d\n", max->Element);

    position min = findMin(tree);
    printf("最小值：%d\n", min->Element);

    int x = 8;
    printf("删除节点 %d \n", x);
    tree = Delete(x, tree);
    printf("中序遍历：\n");
    inorder_avltree(tree);
    makeempty(tree);

    system("pause");
    return 0;
}


static int Height(position P)
{
    if( P == NULL)
        return -1;
    else 
        return P->Height;
}

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

avlTree Insert(elementType x, avlTree T)
{
    if(T == NULL)
    {
        //create and return a one-node tree
        T = (avlTree) malloc(sizeof (struct AvlNode));
        if(T == NULL)
            printf("out of space\n");
        else    
        {
            T->Element = x;
            T->Height = 0;
            T->Left = NULL;
            T->Right = NULL;
        }
    }
    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 = LLrotation(T);
            else 
                T = LRrotation(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 = RRrotation(T);
            else T = RLrotation(T);}
        }

    }
    //element is in the tree already, we'll do nothing
    T->Height = Max(Height(T->Left), Height(T->Right)) + 1;
    return T;
}

static position LLrotation(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; // new root
}

static position LRrotation(position K3)
{
    K3->Left = RRrotation(K3->Left);

    return LLrotation(K3);
}

static position RRrotation(position K2)
{
    position K1;
    K1 = K2 ->Right;
    K2->Right = K1->Left;
    K1 ->Left = K2;

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

static position RLrotation(position K3)
{
    K3->Right =LLrotation(K3->Right);

    return RRrotation(K3);
}


position Find(elementType x, avlTree T)
{
    if (T == NULL)
    {
        printf("tree is empty!\n");
        return NULL;
    }
    if(x < T->Element)
        Find(x, T->Left);
    else 
        Find(x, T->Right);
    return T;
}

avlTree makeempty(avlTree T)
{
    if (T == NULL)
    {
        printf("tree is already empty!\n");
        return NULL;
    }
    if (T->Left == NULL && T->Right == NULL)
    {
        free(T);
    }
    if(T->Left == NULL && T->Right != NULL) 
    {
        makeempty(T->Right);
    }

    if(T->Right == NULL && T->Left != NULL) 
    {
        makeempty(T->Left);
    }

    return T;

}

position findMax(avlTree T)
{
    if (T == NULL)
    {
        printf("tree is empty!\n");
        return NULL;
    }
    while (T->Right != NULL)
        T = findMax(T->Right);
    return T;
}

position findMin(avlTree T)
{

    if (T == NULL)
    {
        printf("tree is empty!\n");
        return NULL;
    }
    while (T->Left != NULL)
        T = findMin(T->Left);
    return T;   
}

avlTree Delete(elementType x, avlTree T)
{
    if (T == NULL)
    {
        printf("tree is empty!\n");
        return NULL;
    }
    if (x < T->Element)  //待删除节点在左子树
    {
        T->Left = Delete(x, T->Left);

        //删除节点后，若树失去平衡，则进行相应的调整
        if (Height(T->Right) - Height(T->Left) == 2)  //节点的右子树比左子树高
        {
            if(Height(T->Right->Right) > Height(T->Right->Left))
                RLrotation(T);
            else 
                RRrotation(T);
        }
    }

    else if (x > T->Element) //删除节点在右子树
    {
        T ->Right = Delete(x,T->Right);
        if (Height(T->Left) - Height(T->Right) == 2)
        {
            if(Height(T->Left->Left) > Height(T->Left->Right))
                LRrotation(T->Left);
            else
                LLrotation(T->Left);
        }
    }
    else  //T是对应要删除的节点
    {
        //节点的左右孩子非空
        if (T->Left &&T->Right)
        {
            if (Height(T->Left) > Height(T->Right))
            {
                //如果T的左子树比右子树高，则找出T的左子树中的最大节点
                //将该节点的值赋给T，删除最大节点
                //即用T的左子树的最大节点做T的替身
                position max = findMax(T->Left);
                T->Element = max->Element;
                T->Left = Delete(max->Element, T->Left);
            }
            else
            {
                //如果T的左子树不比右子树高（即它们相等或者右子树比左子树高
                //则找出T的右子树的最小节点，将该节点的值赋给T，删除最小节点
                //即用T的右子树最小节点替换T
                position min = findMin(T->Right);
                T->Element = min->Element;
                T->Right = Delete(min->Element, T->Right);
            }
        }
        else
        {
            position p = T;
            T = T->Left ? T->Left : T->Right;
            free(p);
        }
    }
    return T;
}


void preorder_avltree(avlTree T) //前序遍历树
{
    if (T != NULL)
    {


        printf("%d  ", T->Element);
        preorder_avltree(T->Left);
        preorder_avltree(T->Right);
    }
}

void inorder_avltree(avlTree T) //中序遍历
{
    if(T != NULL)
    {
        inorder_avltree(T->Left);
        printf("%d  ", T->Element);
        inorder_avltree(T->Right);
    }
}


void posterorder_avltree(avlTree T) //后续遍历
{
    if (T != NULL)
    {
        posterorder_avltree(T->Left);
        posterorder_avltree(T->Right);
        printf("%d  ", T->Element);
    }
}

这里写图片描述

reference：http://www.cnblogs.com/skywang12345/p/3576969.html

Luts
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AVL 树
sqjddb的博客
03-10 409
一、AVL树的由来及概念 二、AVL树的原理（旋转） 三、AVL树的实现 四、AVL树的性能
AVL树（动图详解）
2021dragon的博客
12-02 2万+
AVL树（C++实现）
AVL树数据结构平衡二叉查找树
07-16
在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者...
二叉查找树，AVL树
01-07
AVL树（平衡二叉查找树） 具有二叉查找树的全部特性。 每个节点的左子树的高度和右子树高度差值小于等于1（平衡二叉树的性质） 左旋：逆时针旋转两个节点，原先的右节点成为新的父节点，原先的父节点成为原先的右...
avlTree:通用AVL树数据结构
06-18
在AVL树中，任何节点的两个子子树的高度最多相差1； 如果在任何时候它们相差超过 1，则进行重新平衡以恢复此属性。 查找、插入和删除在平均和最坏情况下都需要 O(log n) 时间，其中 n 是操作之前树中的节点数。 ...
感知机与多层网络
源编程之美，达万物之理
07-26 6685
[toc] 之前做车牌识别的时候，在字符识别（OCR）时，使用的是人工神经网络（ANN），这里总结介绍一下人工神经的相关知识。1.神经网络1.1 定义人工神经网络（ANN）又称神经网络（NN），是一种模拟人脑的学习系统的生物模型。神经网络的由大量相互连结的节点构成一个复杂的网络结构，每个节点都有多个输入和一个输出，并且每个输入对应有一个权重因子，节点的输出就是所有这些输入与权重乘积的耦合。 通俗
车牌检测--master opencv
源编程之美，达万物之理
04-19 2995
自动车牌识别（Automatic Number Plate Recognition,ANPR),使用一种光学字符识别（O菩提差了Character Recognition, OCR)和其他方法（如图像分割与检测）来获取车辆牌照的监控方法。 对于一个ANPR系统，最好的是使用一个红外（IR）摄像机来获得车辆牌照，因为在分割这一步，对检测和OCR分割很简单、干净，误差小。这由光学的一下基本原理决定的。
谷歌图片搜索
源编程之美，达万物之理
06-06 1374
对于像谷歌、百度识图这种图像搜索的算法，主要有三个步骤： 将目标图片进行特征提取，描述图像的算法很多，用的比较多的是：SIFT描述子，指纹算法函数，bundling features算法，hash function（散列函数）等。也可以根据不同的图像，设计不同的算法，比如图像局部N阶矩的方法提取图像特征。 将图像特征信息进行编码，并将海量图像编码做查找表。对于目标图像，可以对分辨率较大的图像进行降采
伸展树Splay Tree
源编程之美，达万物之理
05-17 726
伸展树 伸展树的实现 节点定义 伸展树的遍历 查找给的关键值key的节点 查找伸展树中的最小关键值最大关键值的节点 伸展树的旋转 插入节点 创建伸展树节点 创建节点key并旋转为根节点 删除key节点 完整的测试代码伸展树与平衡树（AVL）一样，伸展树（splay tree）也是二叉树的一种，它能在O(log n)内完成插入、删除和查找操作。伸展树的特点： 1. 假设当前节点X的关键值为key，则
最大子序列的和问题
源编程之美，达万物之理
07-21 612
问题描述：给出一个整数数组：a1, a2, a3, … … an;求最大的子序列和（如果数组都为负数，则为0）方法1：遍历求解 从数组的首元素a1开始遍历，一直累加ak，求出最大值。maxsum: 要求的最大子序列和， tempsum: a[i]+a[i+1]+a[i+2]+…+a[n-1];(0<=1//O(N^2) int maxfun(int a[], int n) {
栈 ADT 结构
源编程之美，达万物之理
04-30 612
栈（stack）是限制插入与删除只能在一个位置上进行的表，该位置叫做栈的顶（top）。栈的基本操作包括进栈（push）即插入、出栈（pop）即删除。不允许对空栈进行pop操作。栈与队列不同，队列是先进先出（FIFO），栈是后进先出（LIFO），就是说只有栈顶的元素是可以被访问的。与队列相似，栈也可以通过链表或者数组的形式实现。在单链表的顶端插入可以实现push，删除顶端元素实现pop，Top操作考察
二叉查找树 ADT
源编程之美，达万物之理
05-02 541
二叉树是每个节点最多有两个子树的数结构，即左子树、右子树。二叉树的第i层至多有2^（i-1)个节点，深度为k的二叉树至多有(2^k） - 1个节点。二叉查找树：对于树中的每个节点X，他的左子树中所有关键字值小于X的关键字值，而它的右子树中所有关键字值大于X的关键字值。二叉搜索树可以方便的实现搜索算法。在搜索元素x的时候，我们可以将x和根节点比较: 如果x等于根节点，那么找到x，停止搜索 (终止条件)
数
源编程之美，达万物之理
04-30 516
一颗树是一些节点的集合，这些集合可以是 空集；若非空，则一颗树由称作根（root）的节点r以及0个或多个非空的字数T1， T2， T3， …, Tk组成，这些子树中的每一颗的根都有来自根r的一条有向边（edge）所连接。每一颗子树的根叫做跟r的儿子（child），而r是每一颗子树的根的父亲（parent）。一颗具体的树：1.树的相关术语节点的度：一个节点含有的子树的个数称为该节点的度；树的度：一棵树
AVL树：平衡搜索树的优化策略
AVL树是一种自平衡的二叉搜索树，它是在1962年由G.M.Adelson-Velsky和E.M.Landis发明的，用于优化二叉搜索树的性能，特别是减少搜索时间。引入AVL树的主要目的是为了提高二叉搜索树的效率，确保树的高度保持在最优...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值