AVL树笔记（一）:zig-zag,insert,find,predecessor,successor

AVL树就是一棵平衡的二叉查找树。

其维护平衡的方式是：维护一个平衡因子h，即子树高度，如果左子树高度和右子树高度相差2，那么就旋转把它弄平衡。



这个二叉树明显不平衡，可以发现全部左偏，于是右旋。

右旋就是当前节点的左儿子 的 右儿子是当前节点。

如果当前节点有右儿子，怎么办？

那么把这个右儿子拆下来然后装在当前节点的左儿子上。

如图：





这个二叉树明显不平衡，可以发现全部右偏，于是左旋。

左旋就是当前节点的右儿子 的 左儿子是当前节点。

如果当前节点有左儿子，怎么办？

那么把这个左儿子拆下来然后装在当前节点的右儿子上。

这个不给图了。



这个二叉树明显不平衡，下面右偏上面左偏，于是先左旋再右旋。



这个二叉树明显不平衡，下面左偏上面右偏，于是先右旋再左旋。

说白了就是全部反着来，是不是很好懂？

旋转完了，然后insert。

insert就是先插入进去，然后如果不平衡就旋转一下，就平衡了。

顺便更新h。

insert完了，然后find,predecessor,successor。

find,predecessor,successor就和二叉查找树一样。

明天讲讲delete。

附代码：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
struct node{
int h,v,lc,rc;
}tree[40010];
int cnt,ans,n,val,pred,succ,rt;
int abs(int x)
{
return x<0?-x:x;
}
int zig(int r)
{
int t=tree[r].lc;
tree[r].lc=tree[t].rc;
tree[t].rc=r;
tree[r].h=max(tree[tree[r].lc].h,tree[tree[r].rc].h)+1;
tree[t].h=max(tree[tree[t].lc].h,tree[tree[t].rc].h)+1;
return t;
}
int zag(int r)
{
int t=tree[r].rc;
tree[r].rc=tree[t].lc;
tree[t].lc=r;
tree[r].h=max(tree[tree[r].lc].h,tree[tree[r].rc].h)+1;
tree[t].h=max(tree[tree[t].lc].h,tree[tree[t].rc].h)+1;
return t;
}
int zigzag(int r)
{
tree[r].rc=zig(tree[r].rc);
return zag(r);
}
int zagzig(int r)
{
tree[r].lc=zag(tree[r].lc);
return zig(r);
}
int insert(int r,int x)
{
if(r==0)
{
tree[++cnt].v=x;
tree[cnt].h=1;
return cnt;
}
if(x<tree[r].v)
{
tree[r].lc=insert(tree[r].lc,x);
if(tree[tree[r].lc].h==tree[tree[r].rc].h+2)
{
if(x<tree[tree[r].lc].v)r=zig(r);
else if(x>tree[tree[r].lc].v)r=zagzig(r);
}
}
else if(x>tree[r].v)
{
tree[r].rc=insert(tree[r].rc,x);
if(tree[tree[r].rc].h==tree[tree[r].lc].h+2)
{
if(x>tree[tree[r].rc].v)r=zag(r);
else if(x<tree[tree[r].rc].v)r=zigzag(r);
}
}
tree[r].h=max(tree[tree[r].lc].h,tree[tree[r].rc].h)+1;
return r;
}
bool find(int r,int x)
{
if(r==0)return 0;
if(tree[r].v==x)return 1;
if(tree[r].v<x)return find(tree[r].rc,x);
if(tree[r].v>x)return find(tree[r].lc,x);
}
void predecessor(int r,int x)
{
if(r==0)return;
if(tree[r].v<x)
{
pred=tree[r].v;
predecessor(tree[r].rc,x);
}
else predecessor(tree[r].lc,x);
}
void successor(int r,int x)
{
if(r==0)return;
if(tree[r].v>x)
{
succ=tree[r].v;
successor(tree[r].lc,x);
}
else successor(tree[r].rc,x);
}
int main()
{
scanf("%d%d",&n,&ans);
rt=insert(rt,-99999999);
rt=insert(rt,99999999);
rt=insert(rt,ans);
for(int i=1;i<n;++i)
{
scanf("%d",&val);
if(find(rt,val))continue;
pred=succ=0;
predecessor(rt,val);
successor(rt,val);
ans+=min(abs(pred-val),abs(succ-val));
rt=insert(rt,val);
}
printf("%d\n",ans);
}

这个题是BZOJ1588（HNOI2002）就是求前驱后继的裸题。