AVL树

AVL树是一种自平衡二叉查找树。它的平衡因子等于它的左子树的高度减去它的右子树的高度。只有平衡因子等于1，0，-1的结点是平衡的，不平衡的结点需要通过旋转来保持平衡。因此，在AVL树中任何结点的两个子树的高度差的最大值为1。

google到了一篇代码很简洁易懂的文章，将其中的代码整理了一下：

//AVL Tree
#include <iostream>
#include <algorithm>
using namespace std;

typedef int Type;

struct avl_node{
    Type data;
    avl_node *lchild, *rchild;
}*root;


class avlTree{
public:
    avlTree(){
        root=NULL;
    }

    ~avlTree(){
        delete_tree(root);
    }

    void delete_tree(avl_node *node){
        if(node->lchild!=NULL){
            delete_tree(node->lchild);
        }
        if(node->rchild!=NULL){
            delete_tree(node->rchild);
        }
        delete node;
        node=NULL;
    }

    //get height of a node
    //the height of one single node is 1 (not 0)
    int height(avl_node* node){
        if(node==NULL) return 0;
        int left_h=height(node->lchild);
        int right_h=height(node->rchild);
        return max(left_h,right_h)+1;
    }
    
    //get difference of height of the node's left tree and right tree
    //node will not be NULL
    //calculated by left-right
    int diff(avl_node* node){
        int left_h=height(node->lchild);
        int right_h=height(node->rchild);
        return left_h-right_h;
    }
    
    avl_node* RR_rotation(avl_node* head){
        avl_node* temp=head->rchild;
        head->rchild=temp->lchild;
        temp->lchild=head;
        return temp;
    }
    
    avl_node* LL_rotation(avl_node* head){
        avl_node* temp=head->lchild;
        head->lchild=temp->rchild;
        temp->rchild=head;
        return temp;
    }
    
    avl_node* LR_rotation(avl_node* head){
        head->lchild=RR_rotation(head->lchild);
        return LL_rotation(head);
    }
    
    avl_node* RL_rotation(avl_node* head){
        head->rchild=LL_rotation(head->rchild);
        return RR_rotation(head);
    }
    
    //recursively check and keep the tree balanced
    avl_node* balance(avl_node* head){
        int bal_factor=diff(head);
        //balance factor==2
        if(bal_factor>1){
            if(diff(head->lchild)>0){
                head=LL_rotation(head);
            }
            else{
                head=LR_rotation(head);
            }
        }
        //balance factor=-2
        else if(bal_factor<-1){
            if(diff(head->rchild)>0){
                head=RL_rotation(head);
            }
            else{
                head=RR_rotation(head);
            }
        }
        return head;
    }
    
    avl_node* insert(avl_node* root, Type value){
        if(root==NULL){
            root=new avl_node;
            root->data=value;
            root->lchild=NULL;
            root->rchild=NULL;
            return root;
        }
        else if(value<root->data){
            root->lchild=insert(root->lchild,value);
            root=balance(root);
        }
        else if(value>root->data){
            root->rchild=insert(root->rchild,value);
            root=balance(root);
        }
        return root;
    }
    
    //an interesting way to display the tree horizontally
    void display(avl_node* cur, int level){
        if(cur!=NULL){
            display(cur->rchild, level+1);
            cout<<endl;
            if(cur==root){
                cout<<"Root-> ";
            }
            for(int i=0;i<level&&cur!=root;i++){
                cout<<"        ";
            }
            cout<<cur->data;
            display(cur->lchild, level+1);
        }
    }
    
    void preorder(avl_node* cur){
        if(cur==NULL) return;
        cout<<cur->data<<" ";
        preorder(cur->lchild);
        preorder(cur->rchild);
    }
    
    void inorder(avl_node* cur){
        if(cur==NULL) return;
        inorder(cur->lchild);
        cout<<cur->data<<" ";
        inorder(cur->rchild);
    }
    
    void postorder(avl_node* cur){
        if(cur==NULL) return;
        postorder(cur->lchild);
        postorder(cur->rchild);
        cout<<cur->data<<" ";
    }
};



//for testing
int main()
{
    int choice;
    Type item;
    avlTree avl;
    while (1)
    {
        cout<<"\n---------------------"<<endl;
        cout<<"AVL Tree Implementation"<<endl;
        cout<<"\n---------------------"<<endl;
        cout<<"1.Insert Element into the tree"<<endl;
        cout<<"2.Display Balanced AVL Tree"<<endl;
        cout<<"3.InOrder traversal"<<endl;
        cout<<"4.PreOrder traversal"<<endl;
        cout<<"5.PostOrder traversal"<<endl;
        cout<<"6.Exit"<<endl;
        cout<<"Enter your Choice: ";
        cin>>choice;
        switch(choice)
        {
            case 1:
                cout<<"Enter value to be inserted: ";
                cin>>item;
                root = avl.insert(root, item);
                break;
            case 2:
                if (root == NULL)
                {
                    cout<<"Tree is Empty"<<endl;
                    continue;
                }
                cout<<"Balanced AVL Tree:"<<endl;
                avl.display(root, 1);
                break;
            case 3:
                cout<<"Inorder Traversal:"<<endl;
                avl.inorder(root);
                cout<<endl;
                break;
            case 4:
                cout<<"Preorder Traversal:"<<endl;
                avl.preorder(root);
                cout<<endl;
                break;
            case 5:
                cout<<"Postorder Traversal:"<<endl;
                avl.postorder(root);
                cout<<endl;
                break;
            case 6:
                exit(1);
                break;
            default:
                cout<<"Wrong Choice"<<endl;
        }
    }
    return 0;
}

 

测试结果和原文请见：http://www.sanfoundry.com/cpp-program-implement-avl-trees/