POJ 3481 Double Queue

这是一道Splay_tree题。

伸展树（Splay Tree）是一种二叉排序树， 它能在O(log n)内完成插入、查找和删除操作。它由Daniel Sleator和Robert Tarjan创造。它的优势在于不需要记录用于平衡树的冗余信息。在伸展树上的一般操作都基于伸展操作。

查找树的相关知识

　　各种查找树存在不足。比如：对于一个有n个节点的平衡树，虽然最坏情况下每次查找的时间复杂度不会超过O(logn)，但是如果访问模式不均匀，平衡树的效率就会受到影响。此外，它们还需要额外的空间来存储平衡信息。 

　　这些查找树的设计目标都是减少最坏情况下单次操作时间，但是查找树的典型应用经常需要执行一系列的查找操作，此时更关心的性能指标是所有这些操作总共需要多少时间。对于此类应用，更好的目标就是降低操作的摊平时间，此处的摊平时间是指在一系列最坏情况的操作序列中单次操作的平均时间。获得摊平效率的一种方法 就是使用“自调整”的数据结构。 

　　和平衡的或是其它对结构有明确限制的数据结构比起来，自调整数据结构有以下几个优点： 

　　1、从摊平角度而言，它们忽略常量因子，因此绝对不会比有明确限制的数据结构差。而且由于它们可以根据使用情况进行调整，于是在使用模式不均匀的情况下更加有效。 

　　2、由于无需存储平衡或者其它的限制信息，它们所需的空间更小。 

　　3、它们的查找和更新算法概念简单，易于实现。 

　　当然，自调整结构也有潜在的缺点： 

　　1、它们需要更多的局部调整，尤其是在查找期间。（那些有明确限制的数据结构仅需在更新期间进行调整，查找期间则不用） 

　　2、一系列查找操作中的某一个可能会耗时较长，这在实时应用程序中可能是个不足之处。

伸展树存在的意义

　　假设想要对一个二叉查找树执行一系列的查找操作。为了使整个查找时间更小，被查频率高的那些条目就应当经常处于靠近树根的位置。于是想到设计一个简单方法， 在每次查找之后对树进行重构，把被查找的条目搬移到离树根近一些的地方。splay tree应运而生。splay tree是一种自调整形式的二叉查找树，它会沿着从某个节点到树根之间的路径，通过一系列的旋转把这个节点搬移到树根去。

已知重构方法与伸展树的重构方法

　　先前，已经存在两种重构方法： 

　　1、单旋：在查找完位于节点x中的条目i之后，旋转链接x和其父节点的边。（除非x就是树根） 

　　2、搬移至树根：在查找完位于节点x中的条目i之后，旋转链接x和其父节点的边，然后重复这个操作直至x成为树根。 

　　splay tree的重构方法和搬移至树根的方法相似，它也会沿着查找路径做自底向上的旋转，将被查找条目移至树根。但不同的是，它的旋转是成对进行的，顺序取决于查找路径的结构。为了在节点x处对树进行splay操作，我们需要重复下面的步骤，直至x成为树根为止： 

　　1、第一种情况：如果x的父节点p(x)是树根，则旋转连接x和p(x)的边。（这种情况是最后一步） 

　　2、第二种情况：如果p(x)不是树根，而且x和p(x)本身都是左孩子或者都是右孩子，则先旋转连接p(x)和x的祖父节点g(x)的边，然后再旋转连接x和p(x)的边。 

　　3、第三种情况：如果p(x)不是树根，而且x是左孩子，p(x)是右孩子，或者相反，则先旋转连接x和p(x)的边，再旋转连接x和新的p(x)的边。 

　　在节点x处进行splay操作的时间是和查找x所需的时间成比例的。splay操作不单是把x搬移到了树根，而且还把查找路径上的每个节点的深度都大致减掉了一半。

伸展树（Splay Tree）支持的操作

　　具体操作包括： 

　　1、access(i,t):如果i在树t中，则返回指向它的指针，否则返回空指针。为了实现access(i,t)，可以从树t的根部向下查找i。如果 查找操作遇到了一个含有i的节点x，就在x处进行splay操作，并返回指向x的指针，访问结束。如果遇到了空指针，表示i不在树中，此时就在最后一个非 空节点处进行splay操作，然后返回空指针。如果树是空的，将忽略掉splay操作。 

　　2、insert(i,t):将条目i插入树t中（假设其尚不存在）。为了实现insert(i,t)，首先执行split(i,t)，然后把t换成一个由新的包含有i的根节点组成的树，这个根节点的左右子树分别是split返回的树t1和t2。 

　　3、delete(i,t):从树t中删除条目i（假设其已经存在）。为了实现delete(i,t)，首先执行access(i,t)，然后把t换成其左子树和右子树join之后的新树。 

　　4、jo

#include<iostream>
#include<cstdio>
#include<string>
using namespace std;
struct node
{
   int val, pri;
   node *dad,*left,*right;
   node( int v=0,int p=0 ):val( v ),pri( p )
   {
        dad = left =right = NULL;        
   }    
};
struct Splay
{
   node *root;
   int cnt;
   Splay( ){     root = NULL ; cnt = 0; }
   void zig( node *&x )
   {
      node *y = x->dad;
      node *z = y->dad;
      y->left = x -> right;
      if( y -> left ) y -> left ->dad = y;
      y -> dad =x; x -> right = y;
      x -> dad = z;
      if( z )
      {
          if( z -> left == y ) z -> left = x;
          else z -> right =x;         
      }         
   }
   void zag( node *&x)
   {
      node *y = x->dad;
      node *z = y->dad;
      y -> right = x -> left;
      if( y -> right ) y -> right -> dad =y;
      y -> dad =x ; x -> dad = z;
      x -> left = y;
      if( z )
      {
          if( z -> right == y ) z -> right =x;
          else z -> left = x;        
      }        
   }     
   void Insert( int &val, int &pri )
   {
      if( !cnt )
      {
          root = new node( val ,pri );         
      }         
      else
      {
         node *p = find( pri , root),*q;
         if( p -> pri > pri )
         {
             p->left = new node( val ,pri  );
             p -> left -> dad = p;
             q = p -> left;        
         }           
         else 
         {
            p -> right = new node ( val , pri );
            p -> right -> dad = p;
            q = p -> right; 
         }
         splay( q );
      }
      cnt ++ ;
   }
   node  *merge( node *x,node *y )
   {
      if( !x ) return y;
      node *p = findMax( x );
      if( p )
      {
        splay( p );
        p->right = y;
        if( y )    y->dad = p;
        return p;
      } 
      return NULL;
   }
   void del( node *&x )
   {
      if( !cnt ) return ;
      splay( x );
      root = merge( x -> left ,x -> right );
      if( root ) root -> dad = NULL;
      delete x;
      x = NULL;
      cnt -- ;    
   }
   void splay( node *&x )
   {
     while( x -> dad )
     {
        node *y = x->dad , *z = y -> dad;
        if( z==NULL )
        {
           if( y -> left == x ) zig( x );
           else zag ( x );    
        }    
        else
        {
           if( z == y->left && y == x -> left )
           {
                zig ( y ); zig( x );
            }
            else
            {
               if( z == y->right && y == x -> right )
               {
                  zag( y ); zag( x ); 
                }
                else
                {
                   if( y == z->left && x == y->right )
                   {
                       zag( x ); zig( x );    
                    }    
                    else 
                    {
                       zig( x ); zag( x );    
                    }
                }     
            }    
        }
     }
     root = x;
     root -> dad =NULL;        
   } 
   node *find( int &pri , node *rt )
   {
       if( !rt ) return rt;
       if( rt->pri > pri && rt->left ) 
             return find( pri , rt->left );
       else if( rt -> pri < pri && rt -> right ) return find( pri , rt -> right );
            else return rt;        
   }
   node *findMax( node  *x )
   {
      while( x -> right )
      {
           x = x -> right;        
       }     
       return x;
    }
    node *findMin( node *x )
    {
      while( x -> left )
      {
          x = x -> left;        
      }    
      return x;
    }
    void opt( int choice )
    {
       if( choice == 1 )
       {
          int val ,pri;
          scanf( "%d %d",&val,&pri );
          Insert( val, pri );    
        }
        else
        {
           if( choice == 2 )
           {
              if( cnt  )
              {
                 node *p = findMax( root );
                 printf( "%d\n",p->val );
                 del( p );        
              }    
              else puts( "0" );
            }
            else
            {
               if( choice == 3 )
               {
                   node *p = findMin( root );
                   printf( "%d\n",p->val );
                   del( p );        
               }    
               else puts( "0" );
            }    
        }    
    }
};
int main( )
{
    int N;
    Splay sp;
    while( scanf( "%d" ,&N ),N )
    {
      sp.opt( N );    
    }
   return 0;    
}

in(t1,t2):将树t1和t2合并成一棵树，其中包含之前两棵树的所有条目，并返回合并之后的树。这个操作假设t1中的所有条目都小于t2 中的条目，操作完成之后会销毁t1和t2。为了实现join(t1,t2)，首先访问t1中最大的条目i。访问结束之后，t1的根节点中包含的就是i，它 的右孩子显然为空。于是把t2作为这个根节点的右子树并返回完成之后的新树即可实现join操作。 

　　5、split(i,t):构建并返回两棵树t1和t2，其中t1包含t中所有小于等于i的条目，t2包含t中所有大于i的条目。操作完成之后销毁t。为 了实现split(i,t)，首先执行access(i,t)，然后根据新根节点中的值是大于还是小于等于i来切断这个根节点的左链接或右链接，并返回形 成的两棵树。 

　　另外insert和delete方法有更好的实现，时间复杂度更小： 

　　1、insert(i, t):查找i，把遇到的空指针替换成一个含有i的新节点，然后再在新节点处对树进行splay操作。 

　　2、delete(i, t):查找含有i的节点，设此节点为x，其父节点为y。把x的左右子树合并之后替换掉x，然后再从y处进行splay操作。

伸展树的优势

　　由于Splay Tree仅仅是不断调整，并没有引入额外的标记，因而树结构与标准BST没有任何不同，从空间角度来看，它比Treap、Red-Black Tree、AVL要高效得多。因为结构不变，因此只要是通过左旋和右旋进行的操作对Splay Tree性质都没有丝毫影响，因而它也提供了BST中最丰富的功能，包括快速的拆分和合并（这里指的是将原树拆分成两棵子树，其中一棵子树所有节点都比另一子树小，以及它的逆过程），并且实现极为便捷。这一点是其它结构较难实现的。其时间效率也相当稳定，和Treap基本相当