伸展树（splay）

在书上或者别人的博客上看的时候感觉还不是很明显，但是自己写出来并调试之后感觉真是十分的炫酷

特别是调试的时候，感觉这棵树就好像活的一样

（在不断的访问最后的一个节点的时候，能看到树的层数在不断的减少，直到理论的极限

（如果想知道一颗活的树是什么样的体验，可以自己调试一发

（这里窝为了方便直接用0~n-1作为树的元素，你也可以选择自己喜欢的一个方式

（因为只是第一份代码，所以还没有添加动态删除节点和动态添加节点这两个功能

（以后的可能还会优化图形界面和其它的一些功能

（如果有时间的话

（第一份代码写的比较复杂，不过既然已经调试出来了，还是先放在这里了

#include<bits/stdc++.h>
using namespace std;

struct node{
int val;
node *l,*r;
};

node *newnode(int x){
node *ret = new node;
ret->l=ret->r=NULL;
ret->val = x;
return ret;
}

void zig(node* &o){
node *k = o->l;
o->l = k->r;
k->r = o;
o = k;
}

void zag(node* &o){
node *k = o->r;
o->r = k->l;
k->l = o;
o = k;
}

void inser(int x,node *rot){
if(rot->val > x){
if(rot->l==NULL)
rot->l = newnode(x);
else
inser(x,rot->l);
}
else{
if(rot->r==NULL){
rot->r = newnode(x);
}
else{
inser(x,rot->r);
}
}
}

bool fndx(node *&rot,int x,int &d){
if(rot->val == x){
d = 0;
return true;
}
else{
int k;
if(rot->val > x){    //to left
if(rot->l == NULL || fndx(rot->l,x,k)==false)
return false;
else{
if(k==0){
d = -1;
return true;
}
else{
if(k == -1){ // zig zig
zig(rot);zig(rot);
}
else{ // k=1, zag zig
zag(rot->l);zig(rot);
}
d = 0;
return true;
}
}
}
else{
if(rot->r == NULL || fndx(rot->r,x,k)==false)
return false;
else{
if(k==0){
d = 1;
return true;
}
else{
if(k == 1){ // zag zag
zag(rot);zag(rot);
}
else{ // zig zag
zig(rot->r);zag(rot);
}
d = 0;
return true;
}
}
}
}
}

bool fnd(node *&root,int x){
int k;
if(fndx(root,x,k)==false){
return false;
}
else{
if(k){
if(k==1)
zag(root);
else
zig(root);
}
return true;
}
}

void out(node *s,int d,int k){
if(s->l)
out(s->l,d+1,-1);
for(int i =0;i<d;i++)
printf("   ");
if(k!=0){
printf(" ");
if(k==1)
printf("\\");
else
printf("/");
}
else{
printf("-");
}
printf("%d\n",s->val);
if(s->r)
out(s->r,d+1,1);
}

int n =30;

int main(){
node *root = newnode(0);
for(int i = 1;i<n;i++){
inser(i,root);
}
out(root,0,0);
int x;
while(~scanf("%d",&x)){
printf("after find %d",x);
puts("----------------");
fnd(root,x);
out(root,0,0);
}
return 0;
}

=============update==============

给出一些学习的建议吧

刚开始学的时候建议在纸上模拟几遍左旋和右旋的过程，最好能到想到zig或zag就可以在脑海里模拟出这个过程（

然后看双旋的时候也是

双旋到想到x在哪个方向能在纸上模拟出这个过程就可以了

然后就可以自己独立写一遍了，（这个时候会感觉自己写的十分复杂。。。就像我上面那个代码一样QAQ

再接着可以压缩自己的代码（提示:根据双旋的对称性）

以及下面是我优化过的代码

#include<bits/stdc++.h>
using namespace std;

#define l ch[0]
#define r ch[1]

struct node{
int val;
node *ch[2];
};

node *newnode(int x){
node * ret = new node;
ret->l=ret->r=NULL;
ret->val = x;
return ret;
}

void inser(node *rot,int x){
int d = (rot->val > x)?0:1;
if(rot->ch[d])
inser(rot->ch[d],x);
else
rot->ch[d]=newnode(x);
}

void out(node *s,int d,int k){
if(s->l)
out(s->l,d+1,-1);
for(int i =0;i<d;i++)
printf("   ");
if(k!=0){
printf(" ");
if(k==1)
printf("\\");
else
printf("/");
}
else{
printf("-");
}
printf("%d\n",s->val);
if(s->r)
out(s->r,d+1,1);
}

void print(node *s){
puts("-----");
out(s,0,0);
puts("=====");
}

node *root = newnode(0);

void zg(node* &o,int d){
node * k = o->ch[d];
o->ch[d] = k->ch[1^d];
k->ch[1^d] = o;
o = k;
}

int splay(int x,node *& rot){
if(!rot)
return -1;
if(rot->val == x)
return 2;
else{
int d = rot->val > x?0:1;
int k = splay(x,rot->ch[d]);
if(k==2) return d;
if(k==-1) return -1;
if(k==d){
zg(rot,k); zg(rot,k);
}
else{
zg(rot->ch[d],k);
zg(rot,d);
}
return 2;
}
}

bool fnd(node* &root,int x){
int k = splay(x,root);
if(k==-1)
return false;
if(k!=2){
zg(root,k);
}
return true;
}

int n =16;

int main(){
for(int i = 1;i<n;i++){
inser(root,i);
}
print(root);
int x;
while(~scanf("%d",&x)){
if(x>=n){
for(int i = 0;i<n;i++){
fnd(root,i);
print(root);
}
continue;
}
if(x < 0){
for(int i =n-1;i>=0;i--){
fnd(root,i);
print(root);
}
continue;
}
printf("after find %d",x);
fnd(root,x);
print(root);
}
return 0;
}