van Emda Boas

van Emda Boas维护了一个整数集合[0,Max)(无重复),其中Max必须等于2的正整数次幂。它支持以下操作：
（1）插入一个数字;
（2）删除一个数字；
（3）询问某一个数字在不在这个集合中；
（4）询问集合的最大最小值；
（5）询问一个数字的前驱或者后继。
每个操作的复杂度最大为O(loglog(n))

 #include <cmath>
 #include <algorithm>

 /***
   维护的集合范围为[0,MAXU-1]
   MAXU必须为2的正整数次幂
   MAXU<=2^30
 ***/

 template<int MAXU>
 class VanEmdeBoasTree
 {
 private:

     int m_inValidValue;

     struct TreeNode
     {
         int Min,Max;

         /**
           u为2的某次幂
           设u=2^k
           若k为偶数 UpBit=k/2
           若k为奇数 UpBit=(k+1)/2
           DownBit=k-UpBit
         **/
         int u;
         int UpBit;
         int DownBit;

         TreeNode* summary;
         TreeNode** cluster;

         /**
           x的高UpBit位
         **/
         int high(int x)
         {
             return x>>DownBit;
         }

         /**
           x的低DownBit位
         **/
         int low(int x)
         {
             return x&((<<DownBit)-);
         }

         int index(int hx,int lx)
         {
             return (hx<<DownBit)|lx;
         }
     };
     TreeNode* m_root;
     int m_MAXRANGE;

     /**
        已知u=2^k  返回k
     **/
     int GetSumBit(const int u)
     {
         return int(log2(u)+0.5);
     }

     void build(TreeNode* &root,const int u)
     {
         root->Min=m_inValidValue;
         root->Max=m_inValidValue;
         root->u=u;

         if(==u) return;

         const int k=GetSumBit(u);
         root->UpBit=(k+)>>;
         root->DownBit=k>>;

         root->summary=new TreeNode;
         build(root->summary,<<root->UpBit);

         root->cluster=new TreeNode*[<<root->UpBit];
         for(int i=;i<(<<root->UpBit);i++)
         {
             root->cluster[i]=new TreeNode;
             build(root->cluster[i],<<root->DownBit);
         }
     }

     int GetMinValue(TreeNode *rt) { return rt->Min; }
     int GetMaxValue(TreeNode *rt) { return rt->Max; }

     int getSuccessor(TreeNode* curNode,int x)
     {
         if(==curNode->u)
         {
             if(x==&&curNode->Max==) return ;
             else return m_inValidValue;
         }
         else if(curNode->Min!=m_inValidValue&&x<curNode->Min)
         {
             return curNode->Min;
         }
         else
         {
             const int highX=curNode->high(x);
             const int lowX=curNode->low(x);

             int MaxLow=GetMaxValue(curNode->cluster[highX]);
             if(MaxLow!=m_inValidValue&&lowX<MaxLow)
             {
                 return curNode->index(highX,
                                       getSuccessor(curNode->cluster[highX],lowX));
             }
             else
             {
                 int successCluster=getSuccessor(curNode->summary,highX);
                 if(successCluster==m_inValidValue) return m_inValidValue;
                 else
                 {
                     return curNode->index(successCluster,
                                           GetMinValue(curNode->cluster[successCluster]));
                 }
             }
         }
     }

     int getPredecessor(TreeNode* curNode,int x)
     {
         if(==curNode->u)
         {
             if(==x&&==curNode->Min) return ;
             else return m_inValidValue;
         }
         else if(curNode->Max!=m_inValidValue&&x>curNode->Max)
         {
             return curNode->Max;
         }
         else
         {
             const int highX=curNode->high(x);
             const int lowX=curNode->low(x);

             int MinLow=GetMinValue(curNode->cluster[highX]);
             if(MinLow!=m_inValidValue&&lowX>MinLow)
             {
                 return curNode->index(highX,
                                       getPredecessor(curNode->cluster[highX],lowX));
             }
             else
             {
                 int predCluster=getPredecessor(curNode->summary,highX);
                 if(predCluster==m_inValidValue)
                 {
                     if(curNode->Min!=m_inValidValue&&x>curNode->Min)
                     {
                         return curNode->Min;
                     }
                     else return m_inValidValue;
                 }
                 else
                 {
                     return curNode->index(predCluster,
                                           GetMaxValue(curNode->cluster[predCluster]));
                 }
             }
         }
     }

     void insertEmptyNode(TreeNode* curNode,int x)
     {
         curNode->Min=curNode->Max=x;
     }

     void insert(TreeNode* curNode,int x)
     {
         if(curNode->Min==m_inValidValue)
         {
             insertEmptyNode(curNode,x);
             return;
         }
         if(x==curNode->Min||x==curNode->Max) return;
         if(x<curNode->Min)
         {
             std::swap(x,curNode->Min);
         }
         if(curNode->u>)
         {
             const int highX=curNode->high(x);
             const int lowX=curNode->low(x);
             if(GetMinValue(curNode->cluster[highX])==m_inValidValue)
             {
                 insert(curNode->summary,highX);
                 insertEmptyNode(curNode->cluster[highX],lowX);
             }
             else
             {
                 insert(curNode->cluster[highX],lowX);
             }
         }
         if(x>curNode->Max) curNode->Max=x;
     }

     void remove(TreeNode* curNode,int x)
     {
         if(curNode->Min==curNode->Max)
         {
             curNode->Min=curNode->Max=m_inValidValue;
             return;
         }
         if(curNode->u==)
         {
             if(x==) curNode->Min=;
             else curNode->Min=;
             curNode->Max=curNode->Min;
             return;
         }
         if(x==curNode->Min)
         {
             int firstCluster=GetMinValue(curNode->summary);
             x=curNode->index(firstCluster,
                              GetMinValue(curNode->cluster[firstCluster]));
             curNode->Min=x;
         }

         const int highX=curNode->high(x);
         const int lowX=curNode->low(x);
         remove(curNode->cluster[highX],lowX);
         if(GetMinValue(curNode->cluster[highX])==m_inValidValue)
         {
             remove(curNode->summary,highX);
             if(x==curNode->Max)
             {
                 int summaryMax=GetMaxValue(curNode->summary);
                 if(summaryMax==m_inValidValue) curNode->Max=curNode->Min;
                 else
                 {
                     curNode->Max=curNode->index(summaryMax,
                                                 GetMaxValue(curNode->cluster[summaryMax]));
                 }
             }
         }
         else
         {
             if(x==curNode->Max)
             {
                 curNode->Max=curNode->index(highX,
                                             GetMaxValue(curNode->cluster[highX]));
             }
         }
     }

 public:

     /**
       构造函数需要提供类型的无效值
     **/
     VanEmdeBoasTree(const int inValidValue=-)
     {
         m_MAXRANGE=MAXU;
         m_inValidValue=inValidValue;
         m_root=new TreeNode;
         build(m_root,MAXU);
     }

     /**
       key存在 返回1 否则返回0
     **/
     int isExist(int key)
     {
         if(key<||key>=MAXU) return ;

         TreeNode* curNode=m_root;
         while()
         {
             if(key==curNode->Min||key==curNode->Max) return ;
             else if(==curNode->u) return ;
             else
             {
                 TreeNode *nextNode=curNode->cluster[curNode->high(key)];
                 key=curNode->low(key);
                 curNode=nextNode;
             }
         }
     }

     /**
       查找key的后继 即大于key最小的值
       若没有 返回m_inValidValue
     **/
     int getSuccessor(int key)
     {
         if(key<) return GetMinValue(m_root);
         if(key>=m_MAXRANGE) return m_inValidValue;
         return getSuccessor(m_root,key);
     }

     /**
       查找key的前驱 即小于key最大的值
       若没有 返回m_inValidValue
     **/
     int getPredecessor(int key)
     {
         if(key<) return m_inValidValue;
         if(key>=m_MAXRANGE) return GetMaxValue(m_root);
         return getPredecessor(m_root,key);
     }

     void insert(int key)
     {
         if(key<||key>=m_MAXRANGE) return;
         insert(m_root,key);
     }

     void remove(int key)
     {
         if(key<||key>=m_MAXRANGE) return;
         remove(m_root,key);
     }

     int GetMaxValue()
     {
         return GetMaxValue(m_root);
     }

     int GetMinValue()
     {
         return GetMinValue(m_root);
     }
 };