B树的基本例程：删除

摘要：删除操作与插入基本相似，但是比较复杂(算法部分取自算法导论)。
(0)因为删除操作可以从任意内部节点删除，这导致必须安排它的子女;
(1)除了根节点,一定要保证删除不会使得该节点的元素个数少于t-1个.
(3)因此在递归降至某个节点之前，一定要保证它的父节点有t个子女.

下面分几种情况讨论B树删除的操作：
(1)如果关键字k在节点x中,且x是个叶子节点，则删除x;
(2)如果关键字k在节点x中且x是个内节点，则有如下操作;
a)如果节点x中前于k的子节点y包含至少k个关键字,则找出以y为根的子树前驱k’,递归的删除k’,并在x中用k’取代k.
b)对称的，如果节点x中位于k之后的子节点z包含至少t个关键字,则可以找出k在以z为根的子树中的后继k’，递归的删除k’，并用k’代替k。
c)如果关键字k的前后子节点都只有t-1个关键字,就将y和z合并到y，这使得x失去指向k和z的指针,释放z并将k从y中递归的删除z.
3)如果k不在内节点x中，则确定必包含k的正确子树的根ci[x]，如果ci[x]只有t-1个关键字,执行步骤3（a/b）,保证我们降至一个有t个关键字的节点.
a)如果ci[x]只有t-1个关键字,但他的一个兄弟包含t个关键字,则x中的某一个关键字降至ci[x],将ci[x]相邻兄弟的某一关键字上升到x。
b)如果ci[x]与相邻兄弟都只有t-1个关键字,就将ci[x]与一个兄弟合并,即将x的一个关键字降至新合并的节点（这里会让父节点减少，因此必须保证每一个节点被到达之前都有t的关键字，否则就需要回溯）.

void combine(Position T,Position T2,int x){    //把关键字x,T2中所有的关键字合并入T    int max = maxIndex(T);    int j = 0;    T->data[max + 1] = x;//合并关键字与子节点    for(int i = max + 2;i<=2*DU-2;i++)        T->data[i] = T2->data[j++];       j = 0;    for(int i = max + 2;i<=2*DU-1;i++)        T->child[i] = T2->child[j++];}int FindPrevious(Position T)//前继{    int max = maxIndex(T);       while (!T->isLeaf)       {        T = T->child[max+1];        max = maxIndex(T);       }    return T->data[max];}int FindNext(Position T)//后继{    while(!T->isLeaf)        T = T->child[0];    return T->data[0];}void DeleteBtree(Position *T,int x){    int k,indexmax,j;    int temp,max;    Position C,Temp;//用来保存正确的子节点    if((*T) == NULL)        //没有删除成功        return;    int i = 0;    max = maxIndex(*T);    while(i<= max&&x>(*T)->data[i])        i++;    if  (i<=2*DU-2&&x == (*T)->data[i])        {            if ((*T)->isLeaf == 1)                //x在叶子节点上                shiftLeft(*T,i,1);//左移一位            else                //x在内节点            {                if(  pageSize((*T)->child[i]) >=DU )                {                    k = FindPrevious((*T)->child[i]);                    (*T)->data[i] = k;                    DeleteBtree( &(*T)->child[i],k);               }                else if ( pageSize((*T)->child[i+1]) >=DU )                {                    indexmax = maxIndex((*T)->child[i+1]);                    k = FindNext((*T)->child[i+1]);                    (*T)->data[i] = k;                    DeleteBtree( &(*T)->child[i+1],k);                }                else                {                    //合并                    combine((*T)->child[i],(*T)->child[i+1],x);                    free((*T)->child[i+1]);                    for( j = i;j<=2*DU-3;j++)                    {                        (*T)->data[j] = (*T)->data[j+1];                        (*T)->child[j+1] = (*T)->child[j+2];                    }                    (*T)->data[j] = 0;                    (*T)->child[j+1] = NULL;//以上为对T的关键字和子节点进行移动                    DeleteBtree(&(*T)->child[i],x);//在合并的新节点递归的删除关键字x                }        }//x 在内部节点    }//x在当前节点    else if ((*T)->isLeaf == 1)        puts("not found");    else     {        //继续向下找        C = (*T)->child[i];        if(pageSize(C) == DU-1)        {            max = maxIndex(*T)+1;            temp = -1;            //执行下列步骤保证降至一个包含t个关键字的节点            if(i == 0&&(pageSize((*T)->child[i+1]) >=DU))               temp = 0;//右兄弟            else if ( i == max&&(pageSize((*T)->child[i-1]) >=DU))                temp = 1;//左兄弟            else            {                    if(pageSize((*T)->child[i+1]) >=DU )                        temp = 0;                    else if (pageSize((*T)->child[i-1]) >=DU)                        temp = 1;            }                    //将*T中的合适关键字降入C中，将C的左/右兄弟的合适关键字放入T中                    if(temp == 0)//右兄弟                    {                        C->data[maxIndex(C)+1] = (*T)->data[0];//将T的最小关键字给C作为C的最大关键字                        C->child[maxIndex(C)+2] = (*T)->child[i+1]->child[0];//将右兄弟的最左子节点合并到C                        shiftLeft(*T,0,1);                        (*T)->data[maxIndex(*T)] = (*T)->child[i+1]->data[0];//将右兄弟最小关键字给T的最大                        shiftLeft((*T)->child[i+1],0,1);                    }                    else if (temp == 1)//左兄弟                    {                        max = maxIndex((*T)->child[i-1]);                        shiftRight(C,0);                        C->data[0] = (*T)->data[maxIndex(*T)];                        C->child[0] = (*T)->child[i-1]->child[max+1];                        (*T)->data[maxIndex(*T)] = (*T)->child[i-1]->data[max];//将左兄弟最大关键字给T                        shiftLeft( (*T)->child[i-1],max,1);//删除左兄弟的最大关键字                    }                else                    //合并C与左/右兄弟                {                    if (i== 0)                        //合并右兄弟                    {                    combine(C,(*T)->child[i+1],(*T)->data[i]);                    free((*T)->child[i+1]);                    for( j = i;j<=2*DU-3;j++)                    {                        (*T)->data[j] = (*T)->data[j+1];                        (*T)->child[j+1] = (*T)->child[j+2];                    }                    (*T)->data[i] = 0;                    (*T)->child[j] = NULL;//以上为对T的关键字和子节点进行移动                    }                    else                    {                        //合并左兄弟                        combine((*T)->child[i-1],C,(*T)->data[i-1]);                        free(C);                        C = (*T)->child[i-1];                    for( j = i;j<=2*DU-3;j++)                    {                        (*T)->data[j] = (*T)->data[j+1];                        (*T)->child[j] = (*T)->child[j+1];                    }                    (*T)->data[i-1] = 0;                    (*T)->child[j] = NULL;//以上为对T的关键字和子节点进行移动                    (*T)->child[j+1] = NULL;                    }                }        }                   // C满足至少t个节点,递归删除x        DeleteBtree( &C,x);    }    //检测是否为空，否则删除空根    if(pageSize(*T) == 0)    {        if ((*T)->parent == NULL)        {            Temp = *T;            (*T) = (*T)->child[0];            (*T)->parent = NULL;             free(Temp);        }    }}