伸展树 Splay Tree

Splay Tree 是二叉查找树的一种，它与平衡二叉树、红黑树不同的是，Splay Tree从不强制地保持自身的平衡，每当查找到某个节点n的时候，在返回节点n的同时，Splay Tree会将节点n旋转到树根的位置，这样就使得Splay Tree天生有着一种类似缓存的能力，因为每次被查找到的节点都会被搬到树根的位置，所以当80%的情况下我们需要查找的元素都是某个固定的节点，或者是 一部分特定的节点时，那么在很多时候，查找的效率会是O(1)的效率！当然如果查找的节点是很均匀地分布在不同的地方时，Splay Tree的性能就会变得很差了，但Splay Tree的期望的时间复杂度还是O（nlogn）的。

为了使访问的节点调到树根，必定要有像维护平衡二叉树那样的旋转操作，来维持二叉树节点间的偏序关系；与平衡二叉树类似，Splay有2种旋转操作（左旋zag、右旋zig）和4种旋转情况（LL，LR，RL，RR）；旋转操作要保持二叉查找树的性质，通过对访问点x的位置来判断旋转情况，对应的情况使用对应的旋转操作序列，就可以让x的所属层上升，循环对x操作就可以把x调到根节点的位置。

/ \ p x / \ Zig(x) / \ x <> -----------------> <> p / \ / \ <> <> <> <>

/ \ x p / \ Zag(x) / \ p <> <----------------- <> x / \ / \ <> <> <> <>

 struct node
 {
     int data;
     node *left,*right,*father;
     node(int d=,node* a=NULL,node *b=NULL,node *c=NULL):data(d),left(a),right(b),father(c){}
 }*root;
 void zig(node *k)
 {
     node* fa=k->father;
     fa->left=k->right;
     if (k->right) k->right->father=fa;
     k->right=fa;
     k->father=fa->father;
     fa->father=k;
     if (!k->father) return;
     if (k->father->data>k->data)
         k->father->left=k;
     else
         k->father->right=k;
 }
 void zag(node *k)
 {
     node* fa=k->father;
     fa->right=k->left;
     if (k->left) k->left->father=fa;
     k->left=fa;
     k->father=fa->father;
     fa->father=k;
     if (!k->father) return;
     if (k->father->data>k->data)
         k->father->left=k;
     else
         k->father->right=k;
 }
 void splay(node *k,node *&root)
 {
     while (k->father)
     {
         node *fa=k->father;
         if (fa->father==NULL)
         {
             if (k==fa->left) zig(k);
                else zag(k);

         } else
         {
             node *gf=fa->father;
             if (fa==gf->left && k==fa->left){zig(fa);zig(k);}
             if (fa==gf->left && k==fa->right){zag(k);zig(k);}
             if (fa==gf->right && k==fa->left){zig(k);zag(k);}
             if (fa==gf->right && k==fa->right){zag(fa);zag(k);}
         }
     }
     root=k;
 }

Splay旋转调整代码

插入操作是先在二叉树中找到该插入的位置并插入节点，到这里和普通二叉查找树的操作是一样的，之后要对新插入的节点执行Splay()旋转调整操作。

 node* __insert(int data,node *&p)
 {

     if (p==NULL)
     {
         p=new node(data);
         return p;
     }
     if (data<p->data)
     {
         node *q=__insert(data,p->left);
         p->left->father=p;
         return q;
     } else
     {
         if (data==p->data) return NULL; //Splay Tree中不允许出现相同的数据，否则在旋转是会出错，导致死循环
         node *q=__insert(data,p->right);
         p->right->father=p;
         return q;
     }
 }
 void insert(int data,node *&root)
 {
     node *t=__insert(data,root);
     if (t)splay(t,root);
 }

插入操作

查找操作也是和二叉树中的步骤类似，只是最后要对找到点执行Splay().

 node* __find(int data,node *root)
 {
     if (root==NULL) return NULL;
     if (data==root->data) return root;
     if (data<root->data) return __find(data,root->left);
     return __find(data,root->right);
 }
 node* find(int data,node *&root)
 {
     node *q=__find(data,root);
     if (q) splay(q,root);
     return q;
 }

查找操作

树的合并操作会比较麻烦些，先要用到求树的最大、最小操作，就是把树的最值提到树根，这样树根的左子树或是右子树就是一个空树，如果另一颗树最值操作后的树根满足条件，就可以直接连接上了。那如果不满足条件，就需要把另一树分为2棵树，其中一颗要满足条件，这样合并后还是两棵树，但有一棵树的大小会减少，这样循环下去最终就能和为一棵树了。
     为了简单起见，下面我定义的合并函数只适用于同一根节点的两棵子树合并。

 node *findmax(node *&p) //最大操作
 {
     node *t=p;
     while (t->right) t=t->right;
     splay(t,p);
     return t;
 }
 node* join(node *a,node *b)  //a是左孩子  b是右孩子
 {
      a->father=b->father=NULL;
   if (!a || !b) return (node *)((int)a|(int)b);
     node *t=findmax(a);
     t->right=b;
     b->father=t;
     return t;
 }

有条件的合并操作

要删除一个节点就把这个节点调到根节点，然后把左右孩子树合并，释放要删除节点就可以了。

 void remove(int data,node *&root)
 {
     node *q=find(data,root);
     if (q)
     {
         node *tem=root;
         root=join(root->left,root->right);
         delete tem;
     }
 }

删除操作

可以见得Splay Tree 内存的访问次数是蛮高的