数据结构C语言实现14.自平衡二叉查找树_AVL树

引言

　在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。
　AVL树得名于它的发明者G.M. Adelson-Velsky和E.M. Landis，他们在1962年的论文《An algorithm for the organization of information》中发表了它。
一． AVL树定义
–
平衡二叉树又称AVL树,它或者是一棵空树,或者是具有下列性质的二叉排序树:

它的左子树和右子树都是平衡二叉树,
且左子树和右子树高度之差的绝对值不超过1.

图给出了两棵二叉排序树,树中每个节点旁边所标记的数字是以该节点为根的二叉树的左子树和右子树的高度之差,该数字被称为节点的平衡因子.
```
![平衡与不平衡树平衡因子](http://img.blog.csdn.net/20160821172110061)
```
由平衡二叉树的定义可知, 平衡二叉树中的所有节点的平衡因子只能取1、0或-1中的一个值。平衡因子的绝对值大于1,如带有 -2或2的节点被认为是不平衡的，并需要重新平衡这个树。平衡因子可以直接存储在每个节点中，或从可能存储在节点中的子树高度计算出来。
二叉排序树是一棵完全二叉树或者与折半查找的判定树相似时,其查找性能最好,而当二叉排序树蜕化为单支树时其查找性能最差.因此,二叉排序树最好是一棵平衡二叉树.
保持二叉排序树为平衡二叉树的基本思想是:每当给二叉排序树插入一个新节点时,就检查是否因为这次插入而破坏了平衡;如果破坏了平衡,则找出其中最小的不平衡树,在保持二叉排序树有序的前提下,调整最小不平衡树中节点的关系以达到新的平衡.所谓最小不平衡树即指距插入节点最近且其平衡因子的绝对值大于1的节点做根的这样一棵子树.

)
我们将平衡二叉树定义为:

typedef struct AVL_node{
    int                data;  //节点数据域
    int              height;  //节点高度
    struct AVL_node  * left;  //左孩子
    struct AVL_node  *right;  //右孩子
}AVL_node;                    //节点

typedef AVL_node *AVL_Tree;   //树

二．AVL树的接口

avl_tree.h

#ifndef _AVL_TREE_H_
#define _AVL_TREE_H_

typedef struct AVL_node{
    int                data;  //节点数据域
    int              height;  //节点高度
    struct AVL_node  * left;  //左孩子
    struct AVL_node  *right;  //右孩子
}AVL_node;                    //节点

typedef AVL_node *AVL_Tree;   //树

#define  ONE       (1)
#define  max(a, b) ((a) < (b) ? (b) : (a))


//AVL树的接口
//1.        得到树的高度
int         get_tree_height(AVL_Tree root)             ;
//2.        遍历二叉树
//2.1       前序遍历
void        preorder_avltree(AVL_Tree root)            ;
//2.2       中序遍历
void        inorder_avltree(AVL_Tree root)             ;
//2.3       后序遍历
void        postorder_avltree(AVL_Tree root)           ;

//3.        查找数据域为value的节点
//3.1       递归查找
AVL_node *  find_node(AVL_Tree root, int value)        ; 
//3.2       非递归查找
AVL_node *  find_node_(AVL_Tree root, int value)       ; 
//3.3       找到值最大的节点
AVL_node *  get_max_node(AVL_Tree root)                ;
//3.4       找到值最小的节点
AVL_node *  get_min_node(AVL_Tree root)                ;

//4.        将节点插入到avl树中
AVL_Tree    avltree_insert(AVL_Tree root, int data)    ;    
//5.        从avl树中删除指定数值
AVL_Tree    avltree_delete(AVL_Tree root, int data)    ;
//6.        销毁avl树
void        destroy_avltree(AVL_Tree root)             ;
#endif//_AVL_TREE_H_

三. AVL树的接口实现

查找

可以像普通二叉查找树一样的进行，所以耗费O(log n)时间，因为AVL树总是保持平衡的。不需要特殊的准备，树的结构不会由于查找而改变。（这是与伸展树查找相对立的，它会因为查找而变更树结构。）

插入

AVL树的基本操作一般涉及运作同在不平衡的二叉查找树所运作的同样的算法。但是要进行预先或随后做一次或多次所谓的”AVL旋转”。

有四种种情况可能导致二叉查找树不平衡，分别为：

LL：插入一个新节点到根节点的左子树(Left)的左子树(Left),导致根节点的平衡因子由1变为2
RR：插入一个新节点到根节点的右子树(Right)的右子树(Right),导致根节点的平衡因子由-1变为-2
LR：插入一个新节点到根节点的左子树(Left)的右子树(Right),导致根节点的平衡因子由1变为2
RL：插入一个新节点到根节点的右子树(Righ)的左子树(Left),导致根节点的平衡因子由-1变为-2

针对四种种情况可能导致的不平衡，可以通过旋转使之变平衡。有两种基本的旋转：

1 2	`左旋转：将根节点旋转到（根节点的）右孩子的左孩子位置右旋转：将根节点旋转到（根节点的）左孩子的右孩子位置`

以下图表以四列表示四种情况，每行表示在该种情况下要进行的操作。在左左和右右的情况下，只需要进行一次旋转操作；在左右和右左的情况下，需要进行两次旋转操作。

假设由于在二叉排序树上插入节点而失去平衡的最小子树根节点的指针为a（即a是离插入点最近，且平衡因子绝对值超过1的祖先节点），则失去平衡后进行的规律可归纳为下列四种情况：

单向右旋平衡处理LL：由于在*a的左子树根节点的左子树上插入节点，*a的平衡因子由1增至2，致使以*a为根的子树失去平衡，则需进行一次右旋转操作；

单向左旋平衡处理RR：由于在*a的右子树根节点的右子树上插入节点，*a的平衡因子由-1变为-2，致使以*a为根的子树失去平衡，则需进行一次左旋转操作；

双向旋转（先左后右）平衡处理LR：由于在*a的左子树根节点的右子树上插入节点，*a的平衡因子由1增至2，致使以*a为根的子树失去平衡，则需进行两次旋转（先左旋后右旋）操作。

双向旋转（先右后左）平衡处理RL：由于在*a的右子树根节点的左子树上插入节点，*a的平衡因子由-1变为-2，致使以*a为根的子树失去平衡，则需进行两次旋转（先右旋后左旋）操作。

删除
从AVL树中删除节点node，可以分三种情况:

node的左右子树其中一个为空,则将node指向node的非空孩子,然后释放掉node;
node在左子树,则在左子树删除掉节点之后,检测不平衡状态,是否右边高于左边,然后根据右子树情况,判断是RR,还是RL,进行旋转.
node在右子树,根据删除节点之后是否不平衡,根据左子树判断是否需要LL右旋,或是LR.
或者:
(从AVL树中删除，可以透过把要删除的节点向下旋转成一个葉子節點，接着直接移除这个叶子节点来完成。因为在旋转成葉子節點期间最多有log n个节点被旋转，而每次AVL旋转耗费固定的时间，所以删除处理在整体上耗费O(log n) 时间。)

avl_tree.c

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include "tools.h"
#include "avl_tree.h"


//创建一个节点
static AVL_node *create_node(void)
{
    AVL_node *result = (AVL_node *)Malloc(sizeof(AVL_node));
    if(result == NULL)
    {
        fprintf(stderr, "the memory is full!\n");
        exit(1);
    }
    bzero(result, sizeof(AVL_node));
    return result;
}
//获取节点结构中的高度变量
static int node_height(AVL_Tree node)
{
    if(node == NULL)
    {
        return -1;
    }
    return node->height;
}
//计算节点的高度
static int avl_node_height(AVL_node *node)
{
    return max(node_height(node->left), node_height(node->right)) + 1;
}

//1.        得到树的高度
int      get_tree_height(AVL_Tree root)    //得到avl树的高度
{
    return node_height(root);
}

//2.        遍历二叉树
void     preorder_avltree(AVL_Tree root)    //2.1前序遍历avl树
{
    if(root != NULL)
    {
        printf("%d ", root->data);
        preorder_avltree(root->left);
        preorder_avltree(root->right);
    }
}

void     inorder_avltree(AVL_Tree root)     //2.2中序遍历avl树
{
    if(root != NULL)
    {
        inorder_avltree(root->left);
        printf("%d ", root->data);
        inorder_avltree(root->right);
    }
}

void     postorder_avltree(AVL_Tree root)   //2.3后序列遍历avl树
{
    if(root != NULL)
    {
        postorder_avltree(root->left);
        postorder_avltree(root->right);
        printf("%d ", root->data);
    }
}
//3.查找数据域为value的节点
//3.1.递归方式查找
AVL_node *find_node(AVL_Tree root, int value)
{
    if(root == NULL || root->data == value)
    {
        return root;
    }
    if(value < root->data)//小于,去左子树
    {
        return find_node(root->left, value);
    }
    else
    {
        return find_node(root->right, value);
    }
}
//3.2.非递归方式查找
AVL_node *find_node_(AVL_Tree root, int value)
{
    AVL_node *p_node = root;
    
    while(p_node != NULL)
    {
        if(p_node->data > value)//如果当前节点的值大于被查找的值，则继续比较当前节点的左孩子
        {
            p_node = p_node->left;
        }
        else if(p_node->data < value)//如果当前节点的值小于被查找的值，则继续比较当前节点的右孩子
        {
            p_node = p_node->right;
        }
        else//当前节点的值符合要求
        {
            return p_node;
        }
    }
    return NULL;
}
//3.3       找到值最大的节点
AVL_node *get_max_node(AVL_Tree root)    //找到值最大的节点
{
    AVL_node *p_node = root;

    while(p_node->right != NULL)//最右节点
    {
        p_node = p_node->right;
    }

    return p_node;
}

//3.4       找到值最小的节点
AVL_node *get_min_node(AVL_Tree root)    //找到值最小的节点
{
    AVL_node *p_node = root;
    
    while(p_node->left != NULL)//最左节点
    {
        p_node = p_node->left;
    }
   
    return p_node;
}

//[单旋]-(左旋)
//              3 node             
//             / \
//            A   5 new_root    5
//               / \           / \
//              B   7         3   7
//                 / \       /\   /\
//                C   D     A B  C  D 
//左旋转：将根节点旋转到（根节点的）右孩子的左孩子位置
//1.new_root 指向根节点(3)的右孩子(5),作为新的根节点;
//2.new_root 的左孩子(B)要作为原根节点node(3)的右孩子(node->right = new_root->left);
//3.new_root 的左孩子指向原node(3);
//4.修改节点高度
static AVL_node *avl_rotate_left(AVL_node *node)
{
    AVL_node *new_root = NULL;
    if(NULL == node)
    {
        return NULL;
    }
    //1.2.3.以此,将根节点旋转到右孩子的左孩子位置,
    new_root = node->right;
    node->right = new_root->left;
    new_root->left = node;

    //4.旋转完后修改当前节点的高度(有顺序要求)
    node->height = avl_node_height(node);
    new_root->height = avl_node_height(new_root);

    return new_root;
}
//[单旋]-(右旋)
//                 5               
//                / \
//               3   A          3    
//              / \            / \
//             2   B          2   5
//            / \            /\   /\
//           D   C          D  C B  A     
//右旋转：将根节点旋转到（根节点的）左孩子的右孩子位置
//1.new_root 指向根节点(5)的左孩子(3),作为新的根节点;
//2.new_root 的右孩子(B)要作为原根节点node(5)的左孩子;
//3.new_root 的右孩子指向原node(5);
//4.修改节点高度
static AVL_node *avl_rotate_right(AVL_node *node)
{
    AVL_node *new_root = NULL;
    if(NULL == node)
    {
        return NULL;
    }
    //1.2.3.以此,将根节点旋转到左孩子的右孩子位置;
    new_root = node->left;
    node->left = new_root->right;
    new_root->right = node;

    //4.旋转完后修改当前节点的高度（右顺序要求）
    node->height = avl_node_height(node);
    new_root->height = avl_node_height(new_root);

    return new_root;
}
//[双旋]-左右旋转(先左后右)
//
//        5                5       
//       / \              / \
//      3   A            4   A         4
//     / \              / \           / \
//    B   4            3   D         3   5
//       / \          / \           /\   /\
//      C   D        B   C         B  C D  A
//1.先对node的左孩子进行左旋;
//2.再对node进行右旋;
static AVL_node *avl_rotate_left_right(AVL_node *node)
{
    node->left = avl_rotate_left(node->left);
    return avl_rotate_right(node);
}
//[双旋]-右左旋转(先右后左)
//
//     3           3
//    / \         / \
//   A   5       A   4                4       
//      / \         / \              / \
//     4   B       D   5            3   5
//    / \             / \          / \ / \
//   D   C           C   B        A  D C  B  
//1.先对node的右孩子进行左旋;
//2.再对node进行左旋;
static AVL_node * avl_rotate_right_left(AVL_node *node)
{
    node->right = avl_rotate_right(node->right);
    return avl_rotate_left(node);
}

//4. 将节点插入到avl树中
AVL_Tree avltree_insert(AVL_Tree root, int data)
{
    int height_diff = 0;

    if(NULL == root) //为空,则创建一个节点作为树
    {
        root = create_node();
        root->data = data;
    }
    else if(data < root->data) //需要插入的值比当前根节点小,向左子树插入
    {
        root->left = avltree_insert(root->left, data);
        height_diff = node_height(root->left) - node_height(root->right);
        //height_different = 左子树-右子树(因为向左插入,左边有可能变高)
        if(height_diff > ONE)//左子树高了
        {
            if(data < root->left->data)//左孩子的左子树,LL
            {
                root = avl_rotate_right(root);
            }
            else//左孩子的右子树,LR
            {
                root = avl_rotate_left_right(root);
            }
        }
    }
    else if(data > root->data) //需要插入的值比当前根节点大,向右子树插入
    {
        root->right = avltree_insert(root->right, data);
        height_diff = node_height(root->right) - node_height(root->left);
        //右高左低
        if(height_diff > ONE)
        {
            if(data > root->right->data)//右孩子的右子树,左旋,RR
            {
                root = avl_rotate_left(root);
            }
            else//右孩子的左子树,RL
            {
                root = avl_rotate_right_left(root);
            }
        }
    }
    else
    {
        //data == root->data,已经存在不进行插入;
        fprintf(stderr, "the tree_node has been exist.\n\n");
    }

    root->height = avl_node_height(root);
    return root;
}

//5.0 删除节点操作
static AVL_Tree delete_node(AVL_Tree root, AVL_node *node)
{
    int        height_diff   = 0   ;
    AVL_node * temp          = NULL;
    AVL_node * p_node        = NULL;
    AVL_node * left_max      = NULL;
    AVL_node * right_min     = NULL;

    if(NULL == root || NULL == node)
    {
        return NULL;
    }

    if(node->data < root->data)//待删除节点在左子树
    {
        root->left = delete_node(root->left, node);//删除操作
        //高度差(需要判断是否大于1即破坏平衡)
        height_diff = node_height(root->right) - node_height(root->left);
        //height_diff > 1则进行相应旋转
        if(height_diff > ONE)
        {
            p_node = root->right;
            if(node_height(p_node->left) > node_height(p_node->right))//RL情况,
            {
                root = avl_rotate_right_left(root);
            }
            else//RR,左旋
            {
                root = avl_rotate_left(root);
            }
        }
    }
    else if(node->data > root->data)//待删除节点在右子树
    {
        root->right = delete_node(root->right, node);
        height_diff = node_height(root->left) - node_height(root->right);
        //破坏了平衡,则进行旋转
        if(height_diff > ONE)
        {
            p_node = root->left;
            //删除了右子树的一个节点,
            //若此时,这棵树不平衡,即看其左子树,
            //若左子树的右子树高于左子树,即,在其左子树上的右子树多出来,即LR
            //否则,左子树的右子树低于左子树,LL,左左,即右旋
            if(node_height(root->right) > node_height(root->left))
            {
                root = avl_rotate_left_right(root);
            }
            else
            {
                root = avl_rotate_right(root);
            }
        }
    }
    else//此root即为需要删除的节点
    {
        //root左右子树都不为空
        //if((root->left != NULL) && (root->right != NULL)) 
        if(root->left && root->right)
        {
            //左子树高于右子树
            //1.找出root左子树中最大值节点
            //2.将该节点点的值赋值给root
            //3.删除该左子树中的那个最大节点
            if(node_height(root->left) > node_height(root->right))
            {
                left_max = get_max_node(root->left);           //1.找最大
                root->data = left_max->data;                   //2.赋值给root
                root->left = delete_node(root->left, left_max);//3.删除最大  
            }
            else//左子树低于右子树
            {
                //1.找出该root右子树中最小节点
                //2.此将最小值赋值给root
                //3.删除该最小节点
                right_min = get_min_node(root->right);           //1.找最小
                root->data = right_min->data;                    //2.赋值给root
                root->right = delete_node(root->right,right_min);//3.删除最小
            }
        }
        else//被删除的节点左右孩子至少一个为空
        {
            temp = root;
            if(root->left != NULL)//左孩子不为空,则指向其左孩子
            {
                root = root->left;
            }
            else              //右孩子不为空,则向下指向其右孩子
            {
                root = root->right;
            }
            free(temp);
        }
    }
    return root;
}
//5.1 调整整个树节点的高度
static int adjust_node_height(AVL_Tree root)
{
    int left_height = 0;
    int right_height = 0;

    if(NULL == root)//为空,返回-1
    {
        return -1;
    }
    else if((NULL == root->left) && (NULL == root->right))//叶子节点,高度为0
    {
        return 0;
    }
    else
    {
        //非叶子节点高度 = 左右子树中最大值 + 1
        left_height = adjust_node_height(root->left);
        right_height = adjust_node_height(root->right);
        return max(left_height, right_height) + 1;
    }
}
//5. AVL树中删除指定数据
AVL_Tree avltree_delete(AVL_Tree root, int data)
{
    AVL_node *node = NULL;

    if((node = find_node(root, data)) != NULL)//找到相应节点
    {
        root = delete_node(root, node);//调用删节点函数
        adjust_node_height(root);
    }
    return root;
}
//6 销毁AVL树
void destroy_avltree(AVL_Tree root)
{
    if(NULL == root)
    {
        return ;
    }

    destroy_avltree(root->left);
    destroy_avltree(root->right);
    free(root);
}

四. 函数功能检测

main.c

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

#define COUNT (10)

int main(int argc, char **argv)
{
    int          i = 0   ;
    int      value = 0   ;
    AVL_Tree  root = NULL;
    AVL_node *find = NULL;

    for(i = 0; i < COUNT; ++i)
    {
        value = rand() % (COUNT*COUNT);
        root = avltree_insert(root, value);
        inorder_avltree(root);
        printf("\n");
        if(i == COUNT/2)
        {
            printf("the tree height is: %d\n", get_tree_height(root));
            printf("the max value in tree: %d,\n", get_max_node(root)->data);
            printf("the min value in tree: %d .\n", get_min_node(root)->data);
        }
    }
    printf("then insert %d in avl_tree :\n", COUNT);
    avltree_insert(root, COUNT);
    inorder_avltree(root);
    printf("\n");
    printf("then the max value in avltree: %d,\n", get_max_node(root)->data);
    printf("then the min value in avltree: %d .\n", get_min_node(root)->data);
    printf("\n");
    if((find = find_node(root, COUNT)))
    {
        printf("we find the %d\n", find->data);
    }
    printf("then we delete %d node:\n", COUNT);
    avltree_delete(root, COUNT);
    inorder_avltree(root);
    printf("\n");
    printf("and then the tree height is:%d\n", get_tree_height(root));
    printf("inorder:");
    inorder_avltree(root);
    printf("\n");
    printf("preorder: ");
    preorder_avltree(root);
    printf("\n");
    printf("postorder: ");
    postorder_avltree(root);
    printf("\n");

    printf("destroy\nthis\ntree\n");
    destroy_avltree(root);
}

运行结果

root@aemonair:~/AVL_Tree# cc.sh *.c
Compiling ...
-e CC      avl_tree.c main.c tools.c -g -lpthread -lm
-e         Completed .
-e         Fri Aug 26 10:41:04 CST 2016

root@aemonair:~/AVL_Tree# ./avl_tree 
83 
83 86 
77 83 86 
15 77 83 86 
15 77 83 86 93 
15 35 77 83 86 93 
the tree height is: 2
the max value in tree: 93,
the min value in tree: 15 .
the tree_node has been exist.

15 35 77 83 86 93 
15 35 77 83 86 92 93 
15 35 49 77 83 86 92 93 
15 21 35 49 77 83 86 92 93 
then insert 10 in avl_tree :
10 15 21 35 49 77 83 86 92 93 
then the max value in avltree: 93,
then the min value in avltree: 10 .

we find the 10
then we delete 10 node:
15 21 35 49 77 83 86 92 93 
and then the tree height is:3
inorder:15 21 35 49 77 83 86 92 93 
preorder: 83 35 15 21 77 49 92 86 93 
postorder: 21 15 49 77 35 86 93 92 83 
destroy
this
tree

五. 总结

高度为h的AVL树，节点数N最多$2^h -1$;最少为$\frac{Φ^{h+2}}{\sqrt{5}} - 1$;(其中 Φ = $\frac{1+\sqrt{5}}{2} = 1.618$)

最少为( 其中) )

最少节点数 n 如以斐波那契数列可以用数学归纳法证明：
$N_h = F_{h+2} - 1 ( F_{h+2}是Fibonacci polynomial)$
即:
${ N_{0} = 0 }$(表示AVL Tree高度為0的节点总数)
${ N_{1} = 1}$ (表示AVL Tree高度為1的节点总数)
${ N_{2} = 2} $(表示AVL Tree高度為2的节点总数)
${N_h = N_{h-1} + N_{h-2} + 1}$ (表示AVL Tree高度為h的节点总数)
换句话说，当节点数为N时，高度h最多为$ { log_{\Phi} ( \sqrt{5} *(N+1)) -2 }$。

AVL树,是最早提出的自平衡二叉树,对我们而言,了解及实现关于二叉树节点的左旋右旋,不仅是对AVL树的操作更加深刻,也是为了了解前人智慧结晶的方法.
就算前人实现过,我们有了巨人的肩膀,还是要一步步走上去.
加油.

文章作者: Air

文章链接: http://aemonair.github.io/2016/08/26/Data_Structure_14_AVL_Tree/

DataStruct Tree