算法-排序（6）B树

template <class T>
class Btree:public Mtree<T>{    //B树类继承自m树
public:
    Btree();
    bool Insert(const T& x);
    bool Remove(T& x);
    void LeftAdjust(MtreeNode<T> *p,MtreeNode<T> *q,int d,int j);
    void RightAdjust(MtreeNode<T> *p,MtreeNode<T> *q,int d,int j);
    void compress(MtreeNode<T> *p,int j);
    void merge(MtreeNode<T> *p,MtreeNode<T>* q,MtreeNode<T> *pl,int j);
};

template <class T>
bool Btree<T>::Insert(const T& x){
    //将关键码x插入到一个驻留在磁盘的m阶B树中
    Triple<T> loc=Search(x);
    if(!loc.tag) return false;  //已存在
    MtreeNode<T> *p=loc.r,*q;   //p是关键码要插入的结点地址
    MtreeNode<T> *ap=NULL,*t;   //ap是插入码x的右邻指针
    T k=x;int j=loc.i;   //（k,ap）形成插入二元组
    while(1){
        if(p->n<m-1){    //结点关键码个数未超出
            insertkey(p,j,k,ap);
            PutNode(p);
            return true;
        }
        int s=(m+1)/2;  //准备分裂结点
        insertkey(p,j,k,ap);   //插入后p->n达到m
        q=new MtreeNode<T>;
        move(p,q,s,m);  //将p的key[s+1..m]和ptr[s..m]移动到q的key[1..s-1]和ptr[0..s-1]，p->n改为s-1，q->n改为m-s
        k=p->key[s]; ap=q;  //(k,ap)形成向上插入二元组
        if(p->parent!=NULL){
            t=p->parent;GetNode(t);
            j=0;
            t->key[(t->n)+1]=MAXKEY;
            while(t->key[j+1]<k) j++;  //搜索，找到大于K的关键码停止
            q->parent=p->parent;
            PutNode(p);PutNode(q);
            p=t;   //p上升到父结点，继续调整
        }
        else{      //原p为根，需要产生新根
            root=new MtreeNode<T>;
            root->n=1;root->parent=NULL;
            root->key[1]=k;
            root->ptr[0]=p;
            root->ptr[1]=ap;
            q->parent=p->parent=root;
            PutNode(p);PutNode(q);PutNode(root);
            return true;
        }
    }
}

template <class T>
bool Btree<T>::Remove(const T& x){
    Triple<T> loc=Search(x);
    if(loc.tag) return false;  //未找到
    MtreeNode<T> *p=loc.r,*q,*s;
    int j=loc.i;       //p->key[j]==x
    if(p->ptr[j]!=NULL){   //非叶结点
        s=p->ptr[j];GetNode(s);q=p;
        while(s!=NULL){
            q=s;
            s=s->ptr[0];
        }
        p->key[j]=q->key[1];
        compress(q,1);   //把结点q中1以后的指针和关键码前移，删除key[1]
        p=q;
    }
    else compress(p,j);  //叶结点，直接删除
    int d=(m+1)/2;
    while(1){
        if(p->n<d-1){    //小于最小限制
            j=0;q=p->parent;
            GetNode(q);
            while(j<=q->n && q->ptr[j]!=p)
                j++;
            if(!j) LeftAdjust(p,q,d,j);
            else RightAdjust(p,q,d,j);
            p=q;
            if(p==root) break;
        }
        else break;
    }
    if(root->n==0){
        p=root->ptr[0];
        delete root;
        root=p;
        root->parent=NULL;
    }
    return true;
}

template <class T>
void LeftAdjust(MtreeNode<T> *p,MtreeNode<T> *q,int d,int j){
    MtreeNode<T> *pl=q->ptr[j+1];
    if(pl->n>d-1){    //右兄弟空间还够，仅做调整
        p->n++;
        p->key[p->n]=q->key[j+1];
        q->key[j+1]=pl->key[1];
        p->ptr[p->n]=pl->ptr[0];
        pl->ptr[0]=pl->ptr[1];
        compress(pl,1);
    }
    else merge(p,q,pl,j+1);  //p与pl合并，保留p结点
}

template <class T>
void RightAdjust(MtreeNode<T> *p,MtreeNode<T> *q,int d,int j){
    
}

void compress(MtreeNode<T> *p,int j){
    for(int i=j; i<p-n; i++){  //左移
        p->key[i]=p->key[i+1];
        p->ptr[i]=p->ptr[i+1];
    }
    p->n--;  //结点中元素个数减1
}
void merge(MtreeNode<T> *p,MtreeNode<T>* q,MtreeNode<T> *pl,int j){
    p->key[(p->n)+1]=q->key[j];
    p->ptr[(p->n)+1]=pl->ptr[0];
    for(int i=1; i<=pl->n; i++){
        p->key[(p->n)+i+1]=pl->key[i];
        p->ptr[(p->n)+i+1]=pl->ptr[i];
    }
    compress(q,j);
    p->n=p->n+pl->n+1;
    delete pl;
}