数据结构之树篇3——平衡二叉树（AVL树）

引入

上一篇写了二叉排序树，构建一个二叉排序树，如果构建序列是完全有序的，则会出现这样的情况：

显然这种情况会使得二叉搜索树退化成链表。当出现这样的情况，二叉排序树的查找也就退化成了线性查找，所以我们需要合理调整二叉排序树的形态，使得树上的每个结点都尽量有两个子结点，这样整个二叉树的高度就会大约在\(log(n)\) 左右，其中 \(n\) 为结点个数。

基本性质

? AVL树也称为平衡二叉树，是一种自平衡的二叉排序树，本质上仍然是一颗二叉排序树，只是增加了“平衡”的要求，平衡是指，对AVL树中任何节点的两个子树的高度之差（称为平衡因子）的绝对值不超过 \(1\) 。能保证上面这一点，AVL树的高度就能始终保持在 \(O(logn)\) 级别。

数据结构定义

由于需要对每个结点都得到平衡因子，因此在AVL树的结构中加入一个变量height，用来记录当前结点为根结点的子树的高度：

typedef struct Node
{
    char data;
    int height;
    struct Node* Left;
    struct Node* Right;
}*AVLTree;

获取 root 结点高度：

int getHeight(Node *root){
    if(!root) return 0;//空节点高度为0
    return root->height;
}

基本操作

查找

? AVL树是一颗二叉查找树，因此查找操作与二叉查找树相同。因为AVL树的高度为 \(O(logn)\) 级别，所以查找操作的时间复杂度为 \(O(logn)\)。

可以得到和二叉查找树完全相同的代码：

//找不到返回NULL，找到返回该节点。
//非递归
Node* Find(AVLTree t, int x) {
    if (!t)return NULL;
    if (t->data == x) return t;
    if (x < t->data) return BSTreeFind(t->Left, x);
    if (x > t->data) return BSTreeFind(t->Right, x);
}
//非递归
Node* Find(AVLTree T,int x) {
    BSTree p = T;
    while (p) {
        if (x == p->data)
            return p;
        p = x > p->data ? p->Right : p->Left;
    }
    return NULL;
}

插入

左旋

先抛开AVL树的插入问题，看下面左边的二叉排序树。大家本来和平共处，突然有一天 B 觉得自己的权值比 A 大，要造反，但是B要做根结点，必须也要保证调整后的树仍然是一颗二叉排序树。

☆上所有权值都比A小， ? 上所有权值都比B大，无需在调整中进行位置变动；因为调整后B的左孩子变成了A，那么▲必须移动到其他地方去，因为A、B、▲的权值关系满足 A<▲<B ，所以让▲成为A的右子树即可。

这个调整过程称为左旋，分解调整过程如下：

代码如下：

void L(AVLTree *root){
    Node* temp = (*root)->Right; //root指向结点A，temp指向结点B
    (*root)->Right = temp->Left; //图示步骤2
    temp->Left = *root; //图示步骤3
    root->height = max(getHeight(root->Left), getHeight(root->Rihgt)) + 1;//更新结点A高度
    temp = max(getHeight(temp->Left), getHeight(temp->Rihgt)) + 1;//更新结点B高度
    *root = temp;//图示步骤4
}

右旋

右旋是左旋的逆过程，如下：

分解调整过程如下：

代码如下：

void R(AVLTree *root) {
    Node* temp = (*root)->Left;//root指向结点B，temp指向结点A
    (*root)->Left = temp->Right;
    temp->Right = *root;
    root->height = max(getHeight(root->Left), getHeight(root->Rihgt)) + 1;
    temp = max(getHeight(temp->Left), getHeight(temp->Rihgt)) + 1;
    *root = temp;
}

? 接下来讨论AVL树的插入操作，假设现在已经有一颗平衡二叉树，那么在向其中插入一个结点时，一定会有结点的平衡因子发生改变，此时就可能会有结点的平衡因子大于1 ，这样以该结点为根结点的子树就是失去平衡的，会使平衡二叉树发生失衡的情况可以分为下面四种：

LL、RR型

左左（LL）、右右（RR），LL，RR只表示树型（导致树失去平衡的插入位置），不是左旋、右旋的意思。

对于LL型，需要以A结点为根进行右旋；

对于RR型，需要以A为根结点进行左旋。

所以代码如下：

void RR_Rotate(AVLTree *root){
    L(root);
}

void LL_Rotate(AVLTree *root) {
    R(root);
}

LR，RL型

左右（LR）、右左（RL）。

对于LR型，需要先以B结点为根结点进行一次左旋，再以A结点为根结点进行一次右旋。

对于RL型，需要先以B结点为根结点进行一次右旋，再以A结点为根结点进行一次左旋。

void LR_Rotate(AVLTree *root) {
    L(&(*root)->Left);
    R(root);
}
void RL_Rotate(AVLTree *root) {
    R(&(*root)->Right);
    L(root);
}

插入结点

插入算法就是出现不平衡状态时，判断需要使用哪种旋转方式来使得二叉树保持平衡

AVLTree InsertAVLTree(AVLTree root, int x) {
    if (root == NULL) {
        root = new Node;
        root->Left = NULL;
        root->Right = NULL;
        root->data = x;
        return root;
    }
    if (x > root->data) {
            //递归返回插入位置的父节点或者祖父……。
            root->Right = InsertAVLTree(root->Right, x);
            //如果插入之后失去了平衡
            if (height(root->Left) - height(root->Right) == -2) {
                //如果插入的值大于,当前节点的左孩子节点，说明该节点是插在root的右子树上的
                if (x > root->Left->data) RR_Rotate(&root);
                else RL_Rotate(&root);
            }
    }

    else if (x < root->data) {
        root->Left = InsertAVLTree(root->Left, x);
        if (height(root->Left) - height(root->Right) == 2) {
            if (x < root->Left->data) LL_Rotate(&root);
            else LR_Rotate(&root);
        }
    }
    else {
        cout << "the number is already included." << endl;
        return NULL;
    }
    return root;
}

删除结点

和二叉排序树的节点的删除差不多，就是多出来一个判断从哪个子树删除节点的问题。

void AVLTreeDel(AVLTree *root, int data)
{
    if (!*root) {
        cout << "delete failed" << endl;
        return;
    }
    Node *p = *root;
    if (data == p->data) {
        //左右子树都非空
        if (p->Left && p->Right) {
            //在高度更大的那个子树上进行删除操作
            //进左子树，右转到底，进右子树，左转到底，转弯碰壁，杀孩子。
            if (height(p->Left) > height(p->Right)) {
                Node *pre=NULL,*q = p->Left;
                if (!q->Right)
                    q->Right = p->Right;
                else {
                    while (q->Right) {
                        pre = q;
                        q = q->Right;
                    }
                    pre->Right = q->Left;
                    q->Left = p->Left;
                    q->Right = p->Right;
                }
                *root = q;
            }
            else {
                Node *pre = NULL, *q = p->Right;
                if (!q->Left)
                    q->Left = p->Left;
                else {
                    while (q->Left) {
                        pre = q;
                        q = q->Left;
                    }
                    pre->Left = q->Right;
                    q->Left = p->Left;
                    q->Right = p->Right;
                }
                *root=q;
            }
        }
        else
            (*root) = (*root)->Left ? (*root)->Left : (*root)->Right;
        delete p;
    }
    else if (data < p->data){//要删除的节点在左子树中
        //在左子树中进行递归删除
        AVLTreeDel(&(*root)->Left, data);
        //判断是否仍然满足平衡条件
        if (height(p->Right) - height(p->Left) == 2){
            //如果当前节点右孩子的左子树更高
            if (height(p->Right->Left) > height(p->Right->Right))
                RL_Rotate(root);
            else
                RR_Rotate(root);
        }
    }
    else{
        AVLTreeDel(&(*root)->Right, data);
        if (height(p->Left) - height(p->Right) == 2) {
            if (height((*root)->Left->Left) > height((*root)->Left->Right))
                LL_Rotate(root);
            else
                LR_Rotate(root);
        }
    }
}

完整测试代码：

#pragma once
#include "top.h"

typedef BTreeNode Node, *AVLTree;

void RR_Rotate(AVLTree *root){
    Node* Right = (*root)->Right;
    (*root)->Right = Right->Left;
    Right->Left = *root;
    *root = Right;
}

void LL_Rotate(AVLTree *root) {
    Node* Left = (*root)->Left;
    (*root)->Left = Left->Right;
    Left->Right = *root;
    *root = Left;
}
void LR_Rotate(AVLTree *root) {
    RR_Rotate(&(*root)->Left);
    return LL_Rotate(root);
}
void RL_Rotate(AVLTree *root) {
    LL_Rotate(&(*root)->Right);
    RR_Rotate(root);
}
AVLTree AVLTreeInsert(AVLTree root, int x) {
    if (root == NULL) {
        root = new Node;
        root->Left = NULL;
        root->Right = NULL;
        root->data = x;
        return root;
    }
    if (x > root->data) {
            root->Right = AVLTreeInsert(root->Right, x);
            //递归返回插入位置的父节点或者祖父……，如果失去了平衡
            if (height(root->Left) - height(root->Right) == -2) {
            //如果插入的值大于,当前节点的右孩子节点，说明该节点是插在root的右子树上的
                //if (x > root->Left->data) RR_Rotate(&root);不能保证该节点一定有左子树
                if (x > root->Right->data)RR_Rotate(&root);
                else RL_Rotate(&root);
            }
    }
    else if (x < root->data) {
        root->Left = AVLTreeInsert(root->Left, x);
        if (height(root->Left) - height(root->Right) == 2) {
            if (x < root->Left->data) LL_Rotate(&root);
            else LR_Rotate(&root);
        }
    }
    else {
        cout << "the number is already included." << endl;
        return NULL;
    }
    return root;
}

AVLTree AVLTreeCreat(int *a, int length) {
    AVLTree T = NULL;
    for (int i = 0; i < length; i++) {
        T = AVLTreeInsert(T, a[i]);
    }
    return T;
}
Node* AVLFind(AVLTree T, int x) {
    Node *p = T;
    while (p) {
        if (x == p->data) break;
        p = x > p->data ? p->Right : p->Left;
    }
    return p;
}

AVLTree AVLMax(AVLTree p)
{
    if (!p) return NULL;
    if (p->Right == NULL)
        return p;
    return AVLMax(p->Right);
}

AVLTree AVLMin(AVLTree p)
{
    if (!p)
        return NULL;
    if (p->Left == NULL)
        return p;
    return AVLMin(p->Left);
}

void AVLTreeDel(AVLTree *root, int data)
{
    if (!*root) {
        cout << "delete failed" << endl;
        return;
    }
    Node *p = *root;
    if (data == p->data) {
        //左右子树都非空
        if (p->Left && p->Right) {
            //在高度更大的那个子树上进行删除操作
            //进左子树，右转到底，进右子树，左转到底，转弯碰壁，杀孩子。
            if (height(p->Left) > height(p->Right)) {
                Node *pre=NULL,*q = p->Left;
                if (!q->Right)
                    q->Right = p->Right;
                else {
                    while (q->Right) {
                        pre = q;
                        q = q->Right;
                    }
                    pre->Right = q->Left;
                    q->Left = p->Left;
                    q->Right = p->Right;
                }
                *root = q;
            }
            else {
                Node *pre = NULL, *q = p->Right;
                if (!q->Left)
                    q->Left = p->Left;
                else {
                    while (q->Left) {
                        pre = q;
                        q = q->Left;
                    }
                    pre->Left = q->Right;
                    q->Left = p->Left;
                    q->Right = p->Right;
                }
                *root=q;
            }
        }
        else
            (*root) = (*root)->Left ? (*root)->Left : (*root)->Right;
        delete p;
    }
    else if (data < p->data){//要删除的节点在左子树中
        //在左子树中进行递归删除
        AVLTreeDel(&(*root)->Left, data);
        //判断是否仍然满足平衡条件
        if (height(p->Right) - height(p->Left) == 2){
            //如果当前节点右孩子的左子树更高
            if (height(p->Right->Left) > height(p->Right->Right))
                RL_Rotate(root);
            else
                RR_Rotate(root);
        }
    }
    else{
        AVLTreeDel(&(*root)->Right, data);
        if (height(p->Left) - height(p->Right) == 2) {
            if (height((*root)->Left->Left) > height((*root)->Left->Right))
                LL_Rotate(root);
            else
                LR_Rotate(root);
        }
    }
}

int height(BTree L) {
    if (L == NULL)
        return 0;
    int left = height(L->Left);
    int right = height(L->Right);
    return left >= right ? left + 1 : right + 1;
}

void checkCreat() {
    int length = 10;
    int *a = getNoRepateRandomArray(length, 10);

    for (int i = 0; i < length; i++) {
        cout << a[i] << ",";
    }

    cout << endl;
    AVLTree T = AVLTreeCreat(a, length);
    int t = rand() % length;
    AVLTreeDel(&T, a[t]);
    for (int i = t; i < length - 1; i++) {
        a[i] = a[i + 1];
    }

    Preorder(T);
    cout << endl;
    Inorder(T);
    cout << endl;
    Postorder(T);
    cout << endl;
    free(a);
}

原文地址：https://www.cnblogs.com/czc1999/p/11794808.html

时间： 2024-11-01 17:59:59

数据结构之树篇3——平衡二叉树（AVL树）的相关文章

java数据结构与算法之平衡二叉树(AVL树)的设计与实现

[版权申明]未经博主同意,不允许转载!(请尊重原创,博主保留追究权) http://blog.csdn.net/javazejian/article/details/53892797 出自[zejian的博客] 关联文章: java数据结构与算法之顺序表与链表设计与实现分析 java数据结构与算法之双链表设计与实现 java数据结构与算法之改良顺序表与双链表类似ArrayList和LinkedList(带Iterator迭代器与fast-fail机制) java数据结构与算法之栈(Stack)设

图解平衡二叉树,AVL树（一）

图解平衡二叉树,AVL树(一) 学习过了二叉查找树,想必大家有遇到一个问题.例如,将一个数组{1,2,3,4}依次插入树的时候,形成了图1的情况.有建立树与没建立树对于数据的增删查改已经没有了任何帮助,反而增添了维护的成本.而只有建立的树如图2,才能够最大地体现二叉树的优点. 在上述的例子中,图2就是一棵平衡二叉树.科学家们提出平衡二叉树,就是为了让树的查找性能得到最大的体现(至少我是这样理解的,欢迎批评改正).下面进入今天的正题,平衡二叉树. AVL的定义 平衡二叉查找树:简称平衡二叉树.由前

平衡二叉树,AVL树之图解篇

学习过了二叉查找树,想必大家有遇到一个问题.例如,将一个数组{1,2,3,4}依次插入树的时候,形成了图1的情况.有建立树与没建立树对于数据的增删查改已经没有了任何帮助,反而增添了维护的成本.而只有建立的树如图2,才能够最大地体现二叉树的优点.            在上述的例子中,图2就是一棵平衡二叉树.科学家们提出平衡二叉树,就是为了让树的查找性能得到最大的体现(至少我是这样理解的,欢迎批评改正).下面进入今天的正题,平衡二叉树. AVL的定义 平衡二叉查找树:简称平衡二叉树.由前苏联的数学

【数据结构】平衡二叉排序树BBST之AVL树

平衡二叉排序树 平衡二叉排序树(Balanced Binary Sort Tree),上一篇博客[数据结构]二叉排序树BST讲了BST,并且在最后我们说BST上的操作不会超过O(h),既然树高这么重要,那么BBST的研究就是为了使得树的深度在可接受的范围内渐近意义下达到O(lgn) n个节点组成的二叉树,其高度为lgn取下限时,这棵树是理想平衡的,满足这样条件的树只有完全二叉树和满二叉树,这样的要求未免太苛刻,并且实际中没有意义. 适度平衡:保证树高在渐近意义上不超过O(lgn)适度平衡的树也称

算法学习笔记 平衡二叉树 AVL树

AVL树是最先发明的自平衡二叉查找树, 其增删查时间复杂度都是 O(logn), 是一种相当高效的数据结构.当面对需要频繁查找又经常增删这种情景时,AVL树就非常的适用.[ 博客地址:http://blog.csdn.net/thisinnocence ] AVL树定义 AVL树诞生于 1962 年,由 G.M. Adelson-Velsky 和 E.M. Landis 发明.AVL树首先是一种二叉查找树.二叉查找树是这么定义的,为空或具有以下性质: 若它的左子树不空,则左子树上所有的点的值均小

[重温数据结构]一种自平衡二叉查找树avl树的实现方法

最近重温<数据结构>,发现其中的东西我上学的时候几乎都没写过... 惭愧啊.于是打算一一写点.算是对我逝去青春的纪念... avl树的代码网上有很多, 这个在平衡二叉树里面算是比较简单的. 需要注意的就是树的平衡因子和其子树的平衡因子符号相反的旋转情况.这个在函数avl_rotate_right等中有处理. 目前只做了插入,删除等哪天想做了再做吧. avl.h 1 #define INSERT_ERROR -1 2 #define INSERT_OK 1 3 4 #define LEFT_LE

图解:平衡二叉树,AVL树

学习过了二叉查找树,想必大家有遇到一个问题.例如,将一个数组{1,2,3,4}依次插入树的时候,形成了图1的情况.有建立树与没建立树对于数据的增删查改已经没有了任何帮助,反而增添了维护的成本.而只有建立的树如图2,才能够最大地体现二叉树的优点.            在上述的例子中,图2就是一棵平衡二叉树.科学家们提出平衡二叉树,就是为了让树的查找性能得到最大的体现(至少我是这样理解的,欢迎批评改正).下面进入今天的正题,平衡二叉树. AVL的定义 平衡二叉查找树:简称平衡二叉树.由前苏联的数学

看数据结构写代码（57） AVL树的删除

上一节 已经说了 AVL树的插入 操作,可是 只有 插入,没有删除,怎么能叫 动态 查找表呢. 呵呵,博主 赶紧 去 研究了一番.下面 是成果: AVL树的删除 大致 分为 两大块: 1. 查找节点 并 删除 2. 保持 删除 后 平衡因子的 影响 1. 首先 找到 这个 节点,如果 节点 不存在,直接 退出 函数 if (*tree == NULL){//没找到 return false; } 2.如果 存在,分为 四种情况:(根 二叉 排序树的 删除 类似) 1.节点 为 叶子 节点,直接

python常用算法（5）——树，二叉树与AVL树

1,树 树是一种非常重要的非线性数据结构,直观的看,它是数据元素(在树中称为节点)按分支关系组织起来的结构,很像自然界中树那样.树结构在客观世界中广泛存在,如人类社会的族谱和各种社会组织机构都可用树形象表示.树在计算机领域中也得到了广泛应用,如在编译源程序时,可用树表示源程序的语法结构.又如在数据库系统中,树型结构也是信息的重要组织形式之一.一切具有层次关系的问题都可以用树来描述. 树(Tree)是元素的集合.树的定义是递归的,树是一种递归的数据结构.比如:目录结构.树是由n个结点组成的集合:如