1. 引言
关于B的性质、结构定义、插入操作的处理和相关代码可以参考《算法导论 之 B树 - 创建、插入》一文,而本文主要是讲解B树删除操作的处理过程。在B树的插入操作过程中需要进行结点“分裂”处理,而删除操作正好相反,其需要进行结点“合并”处理,但是它们的共同目的是一致的 —— 维护B树的特征。
一棵m阶的B树,或为空树,或为满足下列特征的m叉树:
1)树中每个结点至多有m棵子树;
2)若根结点不是终端结点,则至少有2棵子树;
3)除根之外,所有非终端结点至少有棵子树;
4)所有的非终端结点中包含下列信息数据:
[n, C0, K0, C1, K1, C2, K2, ...., Kn-1, Cn]
其中:Ki[i=0,1,...,n-1]为关键字,且Ki<Ki+1[i=0, 1, ..., n-2];Ci[i=0,1,...,n]为至上子树根结点的指针,且指针Ci所指子树中所有结点的关键字均小于Ki[i=0,1,...,n-1],但都大于Ki-1[i=1,...,n-1];
2. 处理流程
2.1 删除流程
假设现有一棵m阶的B树,则单个结点的关键字最大个数max=m-1,关键字最小个数min=。假设被删关键字key为结点node中的第idx个关键字,由B树的特征可知,在删除操作之前,结点node的关键字个数num需满足min <=num <= max)。
情况1:被删关键字KEY所在结点node为非最底层结点时
Step1:找到被删关键字KEY在结点node中的位置idx —— 即:node->key[idx]为将被删除的关键字
Step2:找到以子结点child = node->child[idx]为根节点的子树
Step3:再找到该子树中的最大关键字KEY2,并将之拿去填充被删关键字KEY的位置,即:node->key[idx] = KEY2。 —— 子树最大关键字MaxKey被拿走后,相当于子树最大关键字的原位置被空缺了出来,也可在一定意义上理解为最终删除的子树中的最大关键字。
经过思考后可发现:以子结点child = node->child[idx]为根节点的子树中最大关键字一定是在最底层某个结点中,不管要求被删的关键字KEY在哪个结点,均可视为最终被删的关键字都是在最底层结点中,而最底层结点的处理请参考2)的处理流程。
情况2:被删关键字KEY所在结点node为最底层结点时
2.1)删除操作前,结点node的关键字个数num>时,则进行删除操作后,结点node关键字个数num仍然处在min <= num <= max的范围之中,此时删除操作处理完成;
2.2)删除操作前,结点node的关键字个数num=时,则进行删除操作后,结点node的关键字个数num<,显然已经不符合B树的特征,为了维护B树的特征,此时需要进行的处理有2种情况:
2.2.1)如果结点node的兄弟结点brother的结点个数num>时,则结点node可以向brother借用一个结点,但是需要以父结点的关键字为跳板,此时删除操作处理完成;
2.2.2)如果结点node的兄弟结点brother的节点个数num=时,则将node和brother进行合并为一个结点new,同时需要将父结点parent中夹在node和brother之间的关键字插入到新结点new中。如果父结点parent中的一个关键字被插入到了新结点后,父结点parent的关键字个数num>=,则删除操作处理完成; 如果父结点parent的关键字个数num<,则父结点parent此时已经不满足B树特征,则需以父结点为操作对象进行2.2)中的情况判断,并依次类推直至根结点。
2.2 图形解说
2.3 代码实现
/******************************************************************************
**函数名称: btree_delete
**功 能: 删除指定关键字
**输入参数:
** btree: B树
** key: 关键字
**输出参数: NONE
**返 回: 0:success !0:failed
**实现描述:
**注意事项:
**作 者: # Qifeng.zou # 2014.03.12 #
******************************************************************************/
int btree_delete(btree_t *btree, int key)
{
int idx = 0;
btree_node_t *node = btree->root;
while(NULL != node)
{
for(idx=0; idx<node->num; idx++)
{
if(key == node->key[idx])
{
return _btree_delete(btree, node, idx);
}
else if(key < node->key[idx])
{
break;
}
}
node = node->child[idx];
}
return 0;
}
/******************************************************************************
**函数名称: _btree_delete
**功 能: 在指定结点删除指定关键字
**输入参数:
** btree: B树
** node: 指定结点
** idx: 将被删除的关键字在结点node中位置(0 ~ node->num - 1)
**输出参数: NONE
**返 回: 0:success !0:failed
**实现描述:
** 使用node->child[idx]中的最大值替代被删除的关键字,
** 并依次向下处理直至最底层结点,
** -- 其实最终其处理过程相当于是删除最底层结点的关键字
**注意事项:
**作 者: # Qifeng.zou # 2014.03.12 #
******************************************************************************/
static int _btree_delete(btree_t *btree, btree_node_t *node, int idx)
{
btree_node_t *orig = node, *child = node->child[idx];
/* 使用node->child[idx]中的最大值替代被删除的关键字 */
while(NULL != child)
{
node = child;
child = node->child[child->num];
}
orig->key[idx] = node->key[node->num - 1];
/* 最终其处理过程相当于是删除最底层结点的关键字 */
node->key[--node->num] = 0;
if(node->num < btree->min)
{
return btree_merge(btree, node);
}
return 0;
}
/******************************************************************************
**函数名称: btree_merge
**功 能: 合并结点
**输入参数:
** btree: B树
** node: 该结点关键字数num<min
**输出参数: NONE
**返 回: 0:success !0:failed
**实现描述:
** 处理情况分类:
** 1) 合并结点的情况: node->num + brother->num + 1 <= max
** 2) 借用结点的情况: node->num + brother->num + 1 > max
**注意事项:
** node此时为最底层结点
**作 者: # Qifeng.zou # 2014.03.12 #
******************************************************************************/
static int btree_merge(btree_t *btree, btree_node_t *node)
{
int idx = 0, m = 0, mid = 0;
btree_node_t *parent = node->parent, *right = NULL, *left = NULL;
/* 1. node是根结点, 不必进行合并处理 */
if(NULL == parent)
{
if(0 == node->num)
{
if(NULL != node->child[0])
{
btree->root = node->child[0];
node->child[0]->parent = NULL;
}
else
{
btree->root = NULL;
}
free(node);
}
return 0;
}
/* 2. 查找node是其父结点的第几个孩子结点 */
for(idx=0; idx<=parent->num; idx++)
{
if(parent->child[idx] == node)
{
break;
}
}
if(idx > parent->num)
{
fprintf(stderr, "[%s][%d] Didn't find node in parent's children array!\n", __FILE__, __LINE__);
return -1;
}
/* 3. node: 最后一个孩子结点(left < node)
* node as right child */
else if(idx == parent->num)
{
mid = idx - 1;
left = parent->child[mid];
/* 1) 合并结点 */
if((node->num + left->num + 1) <= btree->max)
{
return _btree_merge(btree, left, node, mid);
}
/* 2) 借用结点:brother->key[num-1] */
for(m=node->num; m>0; m--)
{
node->key[m] = node->key[m - 1];
node->child[m+1] = node->child[m];
}
node->child[1] = node->child[0];
node->key[0] = parent->key[mid];
node->num++;
node->child[0] = left->child[left->num];
if(NULL != left->child[left->num])
{
left->child[left->num]->parent = node;
}
parent->key[mid] = left->key[left->num - 1];
left->key[left->num - 1] = 0;
left->child[left->num] = NULL;
left->num--;
return 0;
}
/* 4. node: 非最后一个孩子结点(node < right)
* node as left child */
mid = idx;
right = parent->child[mid + 1];
/* 1) 合并结点 */
if((node->num + right->num + 1) <= btree->max)
{
return _btree_merge(btree, node, right, mid);
}
/* 2) 借用结点: right->key[0] */
node->key[node->num++] = parent->key[mid];
node->child[node->num] = right->child[0];
if(NULL != right->child[0])
{
right->child[0]->parent = node;
}
parent->key[mid] = right->key[0];
for(m=0; m<right->num; m++)
{
right->key[m] = right->key[m+1];
right->child[m] = right->child[m+1];
}
right->child[m] = NULL;
right->num--;
return 0;
}
/******************************************************************************
**函数名称: _btree_merge
**功 能: 合并结点
**输入参数:
** btree: B树
** node:
** brother:
**输出参数: NONE
**返 回: 0:success !0:failed
**实现描述:
**注意事项:
**作 者: # Qifeng.zou # 2014.03.12 #
******************************************************************************/
static int _btree_merge(btree_t *btree, btree_node_t *left, btree_node_t *right, int mid)
{
int m = 0;
btree_node_t *parent = left->parent;
left->key[left->num++] = parent->key[mid];
memcpy(left->key + left->num, right->key, right->num*sizeof(int));
memcpy(left->child + left->num, right->child, (right->num+1)*sizeof(int));
for(m=0; m<=right->num; m++)
{
if(NULL != right->child[m])
{
right->child[m]->parent = left;
}
}
left->num += right->num;
for(m=mid; m<parent->num-1; m++)
{
parent->key[m] = parent->key[m+1];
parent->child[m+1] = parent->child[m+2];
}
parent->key[m] = 0;
parent->child[m+1] = NULL;
parent->num--;
free(right);
/* Check */
if(parent->num < btree->min)
{
return btree_merge(btree, parent);
}
return 0;
}