AVL树入门

AVL树，平衡树的一种，插入，删除，询问均为O(lgn)。

这些天学了下它的实现，（删除貌似很麻烦，还不会。。）

它的插入同查找树，之后靠旋转来维持平衡。

旋转分4种情形：LL, LR, RL, RR;

LL 可以 由一次右单旋平衡，与之对称的，RR 可以 由一次左单旋平衡。

LR 则须 由一次左单旋，先变为LL，再由一次右单旋平衡 。（即一次左右双旋）

RL 与之对称的，一次右左双旋。

详见：

http://blog.csdn.net/gabriel1026/article/details/6311339

 

应用一：动态查询 整颗树中第k大数。

hdu 4006: http://acm.hdu.edu.cn/showproblem.php?pid=4006

题意不含删除操作~， O(qlgn)

 

#include<map>
#include<set>
#include<list>
#include<cmath>
#include<ctime>
#include<queue>
#include<stack>
#include<cctype>
#include<cstdio>
#include<string>
#include<vector>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define MAXN 1000005
#define INF 0x3f3f3f3f
#define LL long long
#define Test() cout<<"Test"<<endl;
#define Debug(a) cout<<#a<<" = "<<a<<endl;
#define Debug2(a,b) cout<<#a<<" = "<<a<<" , "<<#b<<" = "<<b<<endl;
using namespace std;

struct node{
    int v, h;    // v：value， h: hight
    int l, r;    // 2 children
    int c;        // 树的size, 即节点数
};
typedef struct node AVL;    //inscreasing order
AVL t[MAXN];
int root, ie;

void init(){
    root = 0, ie = 1;
    t[0].h = -1;    //以t[0]为空树。
    t[0].c = 0;
}

void pushUp(int p){
    int l=t[p].l, r=t[p].r;
    t[p].h = max(t[l].h, t[r].h)+1;
    t[p].c = t[l].c + t[r].c + 1;
}

//L(), R() 均为单旋， 以 q 为轴，将p向下旋
void L(int &p){        // p在q的左边， 称之为左单旋
    int q=t[p].r, tmp;
    t[p].r = t[q].l;
    t[q].l = p;
    tmp=p, p=q, q=tmp;    //由于此时q为根, swap(p, q)    
    pushUp(q);            //先q后p
    pushUp(p);
}

void R(int &p){        // p在q的右边， 称之为右单旋
    int q=t[p].l, tmp;
    t[p].l = t[q].r;
    t[q].r = p;
    tmp=p, p=q, q=tmp;        
    pushUp(q);    
    pushUp(p);
}
/*
void print(int p){
    printf(",(");
    if(p){
        printf("%d", t[p].v);
        print(t[p].l);        
        print(t[p].r);
    }
    printf("),");
}
*/
void add(int &p, int v, bool f){    //对于重复元素， f=0： 插在left
    int l=t[p].l, r=t[p].r;
    if(!p){
        //printf("added\n");
        t[ie].v=v, t[ie].c=1;
        t[ie].h = t[ie].l = t[ie].r=0;
        p = ie++;
        //return ;
    }
    else if(v<t[p].v || (v==t[p].v && f==0)){
        //printf("left:\n");
        add(l, v, false); t[p].l = l;    //t[p].l本身须被改变
        if(t[l].h-t[r].h == 2){
            if(v <= t[l].v)
                R(p);
            else{
                L(l); t[p].l=l;
                R(p);
            }
        }
    }else if(v>t[p].v || (v==t[p].v && f)){
        //printf("right:\n");
        add(r, v, true); t[p].r = r;    //t[p].r本身须被改变    
        if(t[r].h-t[l].h == 2){
            //printf("r:\n");
            if(v >= t[r].v)
                L(p);
            else{
                R(r); t[p].r=r;
                L(p);
            } 
        }
    }else{
        ;    //允许重复值
    }
    pushUp(p);
    /*
    printf("p : %d\n", root);
    print(p);
    printf("\n");
    */
}

//void remove(){}

int query(int p, int k){
    int l=t[p].l, r=t[p].r; 
    if(k == t[l].c+1)
        return t[p].v;
    else if(k > t[l].c+1)
        return query(r, k-(t[l].c+1));
    else
        return query(l, k);
}

//hdu 4006
int main()
{
    int m, k, x;
    while(~scanf("%d%d", &m, &k)){
        init();
        while(m--){
            char s[5];
            scanf("%s", s);
            if(s[0] == 'I'){
                cin >> x;
                add(root, x, false);
            }
            else
                printf("%d\n", query(root, t[root].c+1-k));
            
        }
    }

    return 0;
}