数据结构之AVL树

1，概述

　　AVL树是最早提出的自平衡二叉树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。AVL树中查找、插入和删除在最坏情况下是O（log n），平均情况下针对随机键列表构造的AVL树的高度大约是1.011log₂n+0.1（《算法设计与分析，P167》）。因此在平均情况下，查找一棵AVL树需要的比较次数和用折半查找法查找一个有序组几乎是相同的。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。本文介绍了AVL树的设计思想和基本操作。

2，基本术语

　　节点的平衡因子是它的左子树的高度减去它的右子树的高度（有时相反）。带有平衡因子1、0或 -1的节点被认为是平衡的。带有平衡因子 -2或2的节点被认为是不平衡的，并需要重新平衡这个树。平衡因子可以直接存储在每个节点中，或从可能存储在节点中的子树高度计算出来。

3，基本操作

　　AVL树的插入、删除、查找节点操作与普通未平衡的二叉查找树一样。耗费O(log n)时间。与普通二叉查找树的区别是当插入、删除节点时需要保证平衡性。

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

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

（1）LL：插入一个新节点到根节点的左子树（Left）的左子树（Left），导致根节点的平衡因子由1变为2

（2）RR：插入一个新节点到根节点的右子树（Right）的右子树（Right），导致根节点的平衡因子由-1变为-2

（3）LR：插入一个新节点到根节点的左子树（Left）的右子树（Right），导致根节点的平衡因子由1变为2

（4）RL：插入一个新节点到根节点的右子树（Right）的左子树（Left），导致根节点的平衡因子由-1变为-2

　　如图所示，对应的处理方法是：（1）右单转（2）左单转（3）左右双转（4）右左双转。如果有若干节点的平衡因子为±2，先找出最靠近新插入叶子的不平衡节点，然后旋转以该节点为根的树。

4，C++实现

 

#include<iostream>
using namespace std;

#define max(X,Y) ((X > Y) ? X : Y)

class AVLtree{
public:
    AVLtree();
    
    void insert_node(const int &);        //插入节点
    void del_node(const int &);            //删除节点
    bool find_node(const int &);        //查找节点
    void print();                    //中序遍历，相当于顺序打印
    void make_empty();

private:
    struct AVLnode{
        int data;
        struct AVLnode *left,*right;
        int height;            //节点高度
    };
    struct AVLnode * head;    //根节点
    void insert_node(const int &,AVLnode * &);
    bool find_node(const int &,AVLnode * &);
    void clear(AVLnode * &);

    int height(AVLnode *);        //返回指定节点高度信息

    void single_left(AVLnode * &);                //左单转
    void single_right(AVLnode * &);                //右单转
    void double_LR(AVLnode * &);                //左右双转
    void double_RL(AVLnode * &);                //右左双转
    void print(AVLnode * &);
    void make_empty(AVLnode * &);
};

AVLtree::AVLtree()
{
    head = NULL;
}

void AVLtree::insert_node(const int & para)
{
    insert_node(para,head);
}

bool AVLtree::find_node(const int & para)
{
    return find_node(para,head);
}

void AVLtree::print()
{
    print(head);
}

void AVLtree::make_empty()
{
    make_empty(head);
}

void AVLtree::insert_node(const int & para,AVLnode * &root)
{
    if(!root)    //空树
    {
        AVLnode *p = (AVLnode *)malloc(sizeof(AVLnode));
        p->data = para;
        p->left = NULL;
        p->right = NULL;
        p->height = 0;

        root = p;    //使父节点指针指向新插入的节点
    }
    else
    {
        if(para < root->data)    //插入左子树
        {
            insert_node(para,root->left);
            if(height(root->left) - height(root->right) == 2)//不平衡，两种情况，(1)插入左子树的左子树，(3)插入左子树的右子树
            {
                if(para < root->left->data)        //情况(1)
                    single_right(root);
                else
                    double_LR(root);            //情况(3)
            }
        }
        else if(para > root->data)    //插入右子树
        {
            insert_node(para,root->right);
            if(height(root->left) - height(root->right) == -2)//不平衡，两种情况，(4)插入右子树的左子树，(2)插入右子树的右子树
            {
                if(para < root->right->data)    //情况(4)
                    double_RL(root);
                else
                    single_left(root);            //情况(2)
            }
        }
        else    //该值已存在，不作处理
        {}

        //更新节点高度信息
        root->height = max(height(root->left),height(root->right)) + 1;
    }
}

bool AVLtree::find_node(const int &para,AVLnode * &root)
{
    if(root->data == para)
        return true;
    else if(root->data > para && (root->left))
        find_node(para,root->left);
    else if(root->data < para && (root->right))
        find_node(para,root->right);
    else
        return false;
}

void AVLtree::single_left(AVLnode * &root)
{
    AVLnode * temp = root->right;
    root->right = temp->left;
    temp->left = root;

    //修改节点高度
    root->height = max(height(root->left),height(root->right)) + 1;
    temp->height = max(height(temp->left),height(temp->right)) + 1;

    root = temp;    //更新根节点指针
}

void AVLtree::single_right(AVLnode * &root)
{
    AVLnode * temp = root->left;
    root->left = temp->right;
    temp->right = root;

    //修改节点高度
    root->height = max(height(root->left),height(root->right)) + 1;
    temp->height = max(height(temp->left),height(temp->right)) + 1;

    root = temp;    //更新根节点指针
}

void AVLtree::double_LR(AVLnode * &root)
{
    single_left(root->left);
    single_right(root);
}

void AVLtree::double_RL(AVLnode * &root)
{
    single_right(root->right);
    single_left(root);
}

int AVLtree::height(AVLnode * root)
{
    if(!root)
        return -1;
    else
        return root->height;
}


void AVLtree::print(AVLnode * &root)
{
    if(!root)
        return;
    else
    {
        print(root->left);
        cout<<root->data<<endl;
        print(root->right);
    }
}

void AVLtree::make_empty(AVLnode * &root)
{
    if(!root)
        return;
    else
    {
        make_empty(root->left);
        make_empty(root->right);
        delete(root);
    }
    root = NULL;        //缺少这条语句会忘记释放父节点指向本节点的指针，导致重复释放内存，导致错误
}

int main()
{
    AVLtree a;
    int array[7] = {5,6,8,3,2,4,7};
    for(int i=0;i<7;i++)
        a.insert_node(array[i]);
    a.print();        //顺序输出数据

    cout<<a.find_node(7)<<endl;
    cout<<a.find_node(5)<<endl;
    cout<<a.find_node(11)<<endl;
    a.make_empty();
    return 0;
}

　　没有实现删除的算法。

　　最近准备整理下几种树的原理和实现，下一篇是红黑树。