B树的基本例程(1)插入

摘要:B树的基本定义:每个节点x都有以下域：

a)n[x],当前存储在节点x中的关键字数

b)n[x]个关键字本身，以非降序存放;

c)leaf[x],是一个布尔值，标志是否是叶子.

(2)每个节点内还包含n[x]+1个指向其子女的指针;

(3)每个节点都具有相同的深度h。

(4)每个节点能包含的关键字数有一个上界和下界，这些界可以用一个称作B数的最小度数的固定整数t来表示.t>=2;

(5)每个非根节点必须至少有t-1个关键字,每个非根节点内至少有t个子女。

(6)每个节点至多包含2t-1个关键字,所以一个内节点至多有2t个子女;

基本操作：

(1)搜索B树,搜索B树与搜索二叉查找树很相似,只是在每个节点所做的不是个二叉搜索，而是由该节点的子女数决定的.基本思路是遍历该节点的所有关键字，直到要搜索的元素x小于等于某个关键字或者大于所有关键字.

然后判断要搜索的元素就等于临界关键字，或者小于它.或者大于所有关键字.如果该节点是叶子，则没有子女，否则根据情况判断是否继续向下搜索.(这一部分的代码将直接运用到删除例程中)

(2)插入数据：因为B树的特点，因此必须将新的数据插入到一个叶子节点中.但是又不能将关键字插入到满叶子节点，故引入一个分裂操作，将一个满的节点从中间分裂成两个各含t-1个关键字的节点，而中间关键字则被提升到父节点.如果父节点也是满的，则它必须在关键字被插入前分裂.因此在查找过程中，遇到满节点就分裂，这样可以保证每分裂一个满节点时它的父节点不是满的。

int maxIndex(Position p){
int i=0;
for(;i<2*DU;i++){
if(p->data[i]==0)
return i-1;   //如果遇到了0说明前一个下标是最大的下标
}
return 2*DU-2;           //如果到了这里说明该节点是满节点，最大关键字下标是2*DU-2
}
void shiftLeft(Position p,int start,int offset)
{      //start是开始移动的位置，offset 移动的位移
int tmp=start;
int max=maxIndex(p);
if(max==0)
max=1;
for(;tmp<=2*DU-2;tmp++)
{                 //左移关键字
p->data[tmp]=p->data[tmp+offset];
p->data[tmp+offset]=0;       //将无用的关键字置为0
}
tmp=start;
for(;tmp<=2*DU-1;tmp++)
{
p->child[tmp]=p->child[tmp+offset]; //左移子节点指针
p->child[tmp+offset]=NULL;          //将无用的子节点指针置为NULL
}
}

void shiftRight(Position p,int start)
{
//向右移动一位
int max=maxIndex(p);
int index=max; //index 是key的下标
for(;index>=start;index--)
p->data[index+1]=p->data[index]; //右移关键字数组
for(index = max + 1;index>=start;index--)
p->child[index+1] = p->child[index];
}
Position splitPage(Position p,int val)
{
//p节点为需要分裂的满节点,val是用来决定返回递归的新节点是B节点（原来的节点）还是新分裂的C节点
int mid=p->data[DU-1];        //取得p中间位置的节点，它被分裂到父节点中
Position right = pm();             //新建C节点
Position result;
int index=DU;
int i=0;
for(;index<=2*DU-2;index++)
{
//开始复制B节点的关键字数组和子节点指针数组，
right->data[i]=p->data[index];
p->data[index]=0;
right->child[i]=p->child[index];
p->child[index]=NULL;
if(right->child[i]!=NULL)
right->child[i]->parent=right;
//B节点的一部分子节点迁移到了C节点上，所以要重新设置子节点的父节点指针
i++;
}
right->child[i]=p->child[2*DU-1];//子节点指针数组比关键字数组个数多一个
if(right->child[DU-1]!=NULL)
right->child[DU-1]->parent=right; //同时设置最后一个子节点指针的父节点
p->child[2*DU-1]=NULL;
p->data[DU-1]=0;
right->isLeaf=p->isLeaf;                  //设置C节点是否是叶子节点，
if(p->parent==NULL)
{
//如果p节点就是根节点了，那么需要新生成Root节点
Position  root = pm();
p->parent=root;
root->isLeaf=0;
}
Position parent=p->parent;
int first=0;
for(;first<= 2*DU-2;first++){//取得父节点中mid可插入的位置
if(parent->data[first]>mid||parent->data[first]==0)
break;
}
index=2*DU-3;
for(;index>=first;index--)
{
//关键字和子节点指针数组右移1位
parent->data[index+1]=parent->data[index];
parent->child[index+2]=parent->child[index+1];
}
parent->data[first]=mid;  //插入新的关键字mid，和新的子节点指针right
parent->child[first+1]=right;
parent->child[first] = p;//避免生成新节点第一个子节点信息缺少
right->parent=parent;
result = val > mid ? right:p;  //确定返回的节点
return result;
}

void InsertData(Position p,int val)
{
//p表示目的节点，val表示要插入的值
if(pageSize(p)==2*DU-1){  //如果递归的过程中碰到满节点，就先分裂p节点
p=splitPage(p,val); //分裂的过程后，重新设置p节点
}
int index=0;
for(;index<sizeof(p->data)/sizeof(int);index++)
{ //寻找子节点的位置，因为分裂节点保证了p节点不是满节点，所以不用考虑满节点的情况（满节点的话index需要加1）
if(p->data[index]==0||p->data[index]>val){
break;
}
}
if(p->isLeaf==0)
{
//如果不是叶子节点，递归插入到子节点
InsertData(p->child[index],val);
return ;
}
if(pageSize(p)>0) //如果节点中有关键字则右移1个位置
shiftRight(p,index);
p->data[index]=val; //把新的关键字插入到相应的位置
return;
}