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&((1<<DownBit)-1);
        }

        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(2==u) return;

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

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

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

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

    int getSuccessor(TreeNode* curNode,int x)
    {
        if(2==curNode->u)
        {
            if(x==0&&curNode->Max==1) return 1;
            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(2==curNode->u)
        {
            if(1==x&&0==curNode->Min) return 0;
            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>2)
        {
            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==2)
        {
            if(x==0) curNode->Min=1;
            else curNode->Min=0;
            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=-1)
    {
        m_MAXRANGE=MAXU;
        m_inValidValue=inValidValue;
        m_root=new TreeNode;
        build(m_root,MAXU);
    }

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

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

    /**
      查找key的后继 即大于key最小的值
      若没有 返回m_inValidValue
    **/
    int getSuccessor(int key)
    {
        if(key<0) 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<0) return m_inValidValue;
        if(key>=m_MAXRANGE) return GetMaxValue(m_root);
        return getPredecessor(m_root,key);
    }

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

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

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

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