B-树

   B-tree树即B树，B即Balanced，平衡的意思。因为B树的原英文名称为B-tree，而国内很多人喜欢把B-tree译作B-树，其实，这是个非常不好的直译，很容易让人产生误解。如人们可能会以为B-树是一种树，而B树又是另一种树。而事实上是，B-tree就是指的B树。B-树(百度百科)是由R.Bayer和E.M.McCreight与1972提出的一种多路平衡查找树，当查找的文件较大且存放在直接存取设备中时，能够有效地减少查找过程对文件的读取次数，提高查找效率。

 定义:

B-树是一种多路平衡查找树，在文件系统中有所应用。主要用作文件的引索。

  一棵m阶的B-树，或为空树，或者满足一下性质。

(1)每棵树只有一个根结点，根结点的关键字的范围[1,m-1];

(2)根结点至少有两颗子树。

(3)每个节点最多有m棵子树。

(4)除根节点和叶子节点外的非终端结点，所有的节点至少有[m/2](向上取整)个子树。

(5)非叶子节点的关键字范围[[m/2]-1,m-1];

(6)所有的叶子节点位于同一层。

(7)节点的关键字个数比子树个数少一。

(8)所有非终端结点包含下列信息

   (n,A0,K1,A2,K2,....Kn,An)

其中Ki(i=1,2,3,...n)为关键字且Ki<Ki+1;Ai(i=0,1,2,...n)为指向子树的根结点的指针,且Ki小于Ai所指子树的所有关键字值(换而言之Ki大于Ai-1的所有子树关键字的值)。                                                                                                      

下图是典型的3阶B-树

 

B-树结构定义

typedef struct BTNode{    int keynum;    struct BTNode *parent;//父节点    KeyType key[m+1];//关键字    struct BTNode *ptr[m+1];//孩子节点}BTNode,*BTree;

//辅助的result结构体

typedef struct{    BTNode *pt;//指向要插入的节点    int i;//插入的位置    int tag;//1:查找成功;2:查找失败}Result;

基本操作:

  主要讲解插入和删除操作，查找操作各大教材上面都有，就不在赘述:

1)B-树的插入操作(关键是判断m的关键字个数是否达到上限m-1)

  (a)利用查找算法找到插入的位置,若找得到，则说明该关键字，直接返回。否则返回将要插入的结点和位置。

  (b)判断该节点是否存在空位置，即判断该节点关键总数n<=m-1；如果满足，则说明该节点还有空位置，则将关键字直接插入该节点中适当的位置。若不满足，则说明该节点已经没有空位置了，需要将该节点分裂成两个。

   分裂方法:生成一新节点。将原点上的关键字和K(即要插入的关键字)，然后从中间位置将关键字分成两个部分(不包含中间位置关键字)，左部分所含关键字放在旧结点中，右部分所含的关键字放在新生成的结点当中，中间关键字连同新生成节点插入到父节点中。如果父节点关键字总数不满足n<=m-1，则重复上述操作，继续向上分裂.

注意:关键字的插入应该先在叶子节点上面操作。即找到合适的叶子节点进行插入操作，而不是在非终端结点上面直接插入。

   B-树的删除操作

 删除操作的重点是判断该节点的关键字总数是否满足n>=[m/2]-1(后面默认[m/2]表示m/2之后向上取整)，根据性质4可得,B-树的删除也主要分为两步。

  (a)首先利用B-树的查找算法判断该节点是否为叶子节点。若为叶子节点则根据不同的情况进行相应的操作。

  (b)若该节点为非叶子节点，且该节点要删除的关键字为K[i]，自在A[i]中找到最小的关键字Y替代K[i]，然后在叶子节点中去掉Y;

在B-树的叶子节点中删除一个关键字的方法:

  首先将要删除的关键字在叶子节点中删除，然后根据不同的情况作相应的处理。

  a.若被删关键字所在节点总数n>=[m/2]，则直接删除该节点。

  b.若被删关键字所在节点总数n=[m/2]-1，删除之后则不满足B-树的定义，需要对B-树进行调整

     

调整过程为：如果其左右兄弟结点中有“多余”的关键字,即与该结点相邻的右（左）兄弟结点中的关键字数目大于ceil(m/2)-1。则可将右（左）兄弟结点中最小（大）关键字上移至双亲结点。而将双亲结点中小（大）于该上移关键字的关键字下移至被删关键字所在结点中。

   c.如果左右兄弟结点中没有“多余”的关键字，即与该结点相邻的右（左）兄弟结点中的关键字数目均等于ceil(m/2)-1。这种情况比较复杂。需把要删除关键字的结点与其左（或右）兄弟结点以及双亲结点中分割二者的关键字合并成一个结点,即在删除关键字后，该结点中剩余的关键字加指针，加上双亲结点中的关键字K_i一起，合并到A_i（即双亲结点指向该删除关键字结点的左（右）兄弟结点的指针）所指的兄弟结点中去。如果因此使双亲结点中关键字个数小于ceil(m/2)-1，则对此双亲结点做同样处理。以致于可能直到对根结点做这样的处理而使整个树减少一层。

总之，设所删关键字为非终端结点中的Ki，则可以指针Ai所指子树中的最小关键字Y代替Ki，然后在相应结点中删除Y。对任意关键字的删除都可以转化为对最下层关键字的删除。

a、被删关键字Ki所在结点的关键字数目不小于ceil(m/2)，则只需从结点中删除Ki和相应指针Ai，树的其它部分不变。

b、被删关键字Ki所在结点的关键字数目等于ceil(m/2)-1，则需调整。调整过程如上面所述。

c、被删关键字Ki所在结点和其相邻兄弟结点中的的关键字数目均等于ceil(m/2)-1，假设该结点有右兄弟，且其右兄弟结点地址由其双亲结点指针Ai所指。则在删除关键字之后，它所在结点的剩余关键字和指针，加上双亲结点中的关键字Ki一起，合并到Ai所指兄弟结点中（若无右兄弟，则合并到左兄弟结点中）。如果因此使双亲结点中的关字数目少于ceil(m/2)-1，则依次类推键.

 

#include<stdio.h>#include<stdlib.h>#define m 3#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0typedef  int Status;typedef int KeyType;int  Min =m/2+m%2;typedef struct BTNode{    int keynum;    struct BTNode *parent;//父节点    KeyType key[m+1];//关键字    struct BTNode *ptr[m+1];//孩子节点}BTNode,*BTree;typedef struct{    BTNode *pt;//指向找到的结点    int i;//关键字序号    int tag;//1:查找成功;2:查找失败}Result;Status InitBTree(BTree &bt);int Search(BTree bt,KeyType K);Result& SearchBTree(BTree T,KeyType K);Status Insert(BTree &p,int i,KeyType K,BTree ap);Status split(BTree &p,int s,BTree &ap);Status NewRoot(BTree &T,BTree &q,KeyType K,BTree &ap);Status InsertBTree(BTree &T,KeyType K,BTree q,int i);Status CreateBTree(BTree &bt,KeyType *a,int N);void Successor(BTree &p,int i,BTree &q);//void Remove(BTree &p,int i);void Restore(BTree &p,int i);void MoveRight(BTree &p,int i);void MoveLeft(BTree &p,int i);void Combine(BTree &p,int i);int RecDelete(BTree &p,KeyType K);void DeleteBTree(BTree &p,KeyType K);void PrintBTree(BTree);int main(){    int N,a[20];    BTree bt=NULL;KeyType K;Result r;    printf("元素个数:");    scanf("%d",&N);    printf("输入元素序列:");    for(int i=0;i<N;i++)        scanf("%d",&a[i]);    CreateBTree(bt,a,N);PrintBTree(bt);printf("输入删除关键字:");scanf("%d",&K);DeleteBTree(bt,K);PrintBTree(bt);    return 0;}Status InitBTree(BTree &bt){    bt->keynum=0;    for(int i=0;i<=m;i++)    {        bt->key[i]=0;        bt->ptr[i]=NULL;    }    bt->parent=NULL;return OK;}int Search(BTree bt,KeyType K){if(K<bt->key[1])return 0;if(K>=bt->key[bt->keynum])return bt->keynum;    for(int i=1;i<=bt->keynum-1;i++)        if(bt->key[i]<=K&&bt->key[i+1]>K)return i;if(bt->keynum==0)return 0;}Result& SearchBTree(BTree T,KeyType K){    BTree p=T,q=NULL;    Result result;    int i=0,found=FALSE;    while(p&&!found)    {        i=Search(p,K);        if(i>0&&p->key[i]==K)            found=TRUE;        else        {            q=p;            p=p->ptr[i];        }    }    result.i=i;    if(found==TRUE)    {        result.pt=p;        result.tag=1;    }else    {        result.pt=q;        result.tag=0;    }    return result;}Status Insert(BTree &p,int i,KeyType K,BTree ap){if(i==p->keynum){p->key[i+1]=K;p->ptr[i+1]=ap;if(ap)ap->parent=p;p->keynum++;}else{p->keynum++;for(int t=p->keynum;t>=i+2;t--){p->key[t]=p->key[t-1];p->ptr[t]=p->ptr[t-1];}p->key[i+1]=K;p->ptr[i+1]=ap;if(ap)ap->parent=p;}    return OK;}Status split(BTree &p,int s,BTree &ap){    int t=0;    ap=(BTree)malloc(sizeof(BTNode));    if(!ap)    {        printf("malloc error");        return ERROR;    }    InitBTree(ap);    for(int i = s + 1; i <= p->keynum; i++)    {        ap->key[i - s] = p->key[i];        ap->ptr[i - s] = p->ptr[i];if(ap->ptr[i-s])ap->ptr[i-s]->parent=ap;    }ap->ptr[0]=p->ptr[s];if(ap->ptr[0])ap->ptr[0]->parent=ap;ap->keynum=p->keynum-s;    //初始化前面的一段内容for(int j=s;j<=p->keynum;j++){p->key[j]=0;p->ptr[j]=NULL;}p->keynum=s-1;    return OK;}Status NewRoot(BTree &T,BTree &q,KeyType K, BTree &ap){    int s,i;    if(!T)//当根节点为空的之后    {        T=(BTree)malloc(sizeof(BTNode));        if(!T)return ERROR;        InitBTree(T);        T->key[1]=K;T->keynum++;    }    else//返回到最上面的顶点    {        s=T->keynum/2+T->keynum%2;q=(BTree)malloc(sizeof(BTNode));if(!q)return ERROR;InitBTree(q);q->key[1]=K;q->ptr[0]=T;q->ptr[1]=ap;q->keynum++;T->parent=q;if(ap)ap->parent=q;T=q;    }    return OK;}Status InsertBTree(BTree &T,KeyType K,BTree q,int i){    KeyType x=K;    BTree ap=NULL;    int finished=FALSE;    int s;    while(q&&!finished)    {        Insert(q,i,x,ap);        if(q->keynum<m)            finished=TRUE;        else        {            s=m/2+m%2;x=q->key[s];            split(q,s,ap);            q=q->parent;            if(q)                i=Search(q,x);        }    }    if(!finished)//分裂到最高结点，或者T为空树        NewRoot(T,q,x,ap);    return OK;}//创建一个B-TreeStatus CreateBTree(BTree &bt,KeyType *a,int N){    Result result;    for(int i=0;i<N;i++)    {        result=SearchBTree(bt,a[i]);        if(!result.tag)//B-Tree中没有该节点，插入InsertBTree(bt,a[i],result.pt,result.i);    }    return OK;}void PrintBTree(BTree bt){    if(bt)    {        for(int i=1;i<=bt->keynum;i++)            printf("%d ",bt->key[i]);        printf("\n");        for(int t=0;t<=bt->keynum;t++)            PrintBTree(bt->ptr[t]);    }}void DeleteBTree(BTree &bt,KeyType K){    BTree p;    if(RecDelete(bt,K)==0)        printf("关键字%d不在B-树中\n",K);    else    {printf("删除成功!\n");if(bt->keynum==0){p=bt;bt=bt->ptr[0];free(p);}    }}int RecDelete(BTree &p,KeyType K){    int i,j,found;    BTree q,t=NULL,s;    Result r;KeyType P;    if(p==NULL)        return 0;    else    {        r=SearchBTree(p,K);        i=r.i;        q=r.pt;        if(r.tag==1)//找到了该节点        {            if(q->ptr[i-1])//该节点为非叶子节点            {                Successor(q,i,t);//将该节点删除后，从q.ptr[i]中将最小的位置给他P=t->key[1];Remove(t,1);    if(t->keynum<Min-1){   j=Search(t->parent,P);                   Restore(t->parent,j);}            }            else            {                t=q->parent;                j=Search(t,K);                Remove(q,i);//删除叶子节点中的关键字                if(q->keynum<Min-1)                    Restore(t,j);            }        }    }return r.tag;}void Successor(BTree &p,int i,BTree &q){BTree t;    for(q=p->ptr[i];q!=NULL;t=q,q=q->ptr[0])p->key[i]=q->key[1];q=t;}void Remove(BTree &p,int i){    for(int j=i;j<=p->keynum;j++)    {        p->key[i]=p->key[i+1];        p->ptr[i]=p->ptr[i+1];    }p->key[p->keynum]=0;p->ptr[p->keynum]=NULL;    --p->keynum;}void Restore(BTree &p,int i){    //shan删除关键字后，调整整个B-    if(i==0)    {        if(p->ptr[1]->keynum>Min-1)            MoveLeft(p,i);        else            Combine(p,1);    }    else if(i==p->keynum)    {        if(p->ptr[p->keynum-1]->keynum>Min-1)            MoveRight(p,i);        else            Combine(p,p->keynum);    }    else//其他情况即为既有左子树，又有右子树    {        if(p->ptr[i+1]->keynum>Min-1)            MoveLeft(p,i);        else if(p->ptr[i-1]->keynum>Min-1)            MoveRight(p,i);        else            Combine(p,i);    }}void MoveRight(BTree &p,int i){    BTree q;    q=p->ptr[i];    q->keynum++;    for(int t=q->keynum;t>=2;t--)    {        q->key[t]=q->key[t-1];        q->ptr[t]=q=q->ptr[t-1];    }    q->ptr[1]=q->ptr[0];    q->key[1]=p->key[i];    q=p->ptr[i-1];    p->key[i]=q->key[q->keynum];    q->key[q->keynum]=0;    q->ptr[q->keynum]=NULL;    q->keynum--;}void MoveLeft(BTree &p,int i){    BTree q;    q=p->ptr[i];    q->keynum++;    q->key[q->keynum]=p->key[i+1];    q=p->ptr[i+1];    p->key[i+1]=q->key[1];    for(int t=1;t<=q->keynum-1;t++)    {        q->key[t]=q->key[t+1];        q->ptr[t]=q->ptr[t+1];    }    q->key[q->keynum]=0;    q->keynum--;}void Combine(BTree &p,int i){int c;    BTree q;    BTree l;q=p->ptr[i];l=p->ptr[i-1];l->keynum++;l->key[l->keynum]=p->key[i];//合并两个叶子节点for(c=l->keynum+1;c<=l->keynum+q->keynum;c++)l->key[c]=q->key[c-l->keynum];l->keynum+=q->keynum;//删除父节点中分割的关键字for(c=i;c<=p->keynum-1;c++){p->key[c]=p->key[c+1];p->ptr[c]=p->ptr[c+1];}p->key[p->keynum]=0;p->ptr[p->keynum]=NULL;p->keynum--;    free(q);}