B树的定义
假设B树的度为t(t>=2),则B树满足如下要求:(参考算法导论)
(1) 每个非根节点至少包含t-1个关键字,t个指向子节点的指针;至多包含2t-1个关键字,2t个指向子女的指针(叶子节点的子女为空)。
(2) 节点的所有key按非降序存放,假设节点的关键字分别为K[1], K[2] … K[n], 指向子女的指针分别为P[1], P[2]…P[n+1],其中n为节点关键字的个数。则有:
P[1] <= K[1] <= P[2] <= K[2] …..<= K[n] <= P[n+1] // 这里P[n]也指其指向的关键字
(3) 若根节点非空,则根节点至少包含两个子女;
(4) 所有的叶子节点都在同一层。
B树的搜索,search(root, target)
从root出发,对每个节点,找到大于或等于target关键字中最小的K[i],如果K[i]与target相等,则查找成功;否则在P[i]中递归搜索target,直到到达叶子节点,如仍未找到则说明关键字不在B树中,查找失败。
B树的插入,insert(root, target)
B树的插入需要沿着搜索的路径从root一直到叶节点,根据B树的规则,每个节点的关键字个数在[t-1, 2t-1]之间,故当target要加入到某个叶子时,如果该叶子节点已经有2t-1个关键字,则再加入target就违反了B树的定义,这时就需要对该叶子节点进行分裂,将叶子以中间节点为界,分成两个包含t-1个关键字的子节点,同时把中间节点提升到该叶子的父节点中,如果这样使得父节点的关键字个数超过2t-1,则要继续向上分裂,直到根节点,根节点的分裂会使得树加高一层。
上面的过程需要回溯,那么能否从根下降到叶节点后不回溯就能完成节点的插入呢?答案是肯定的,核心思想就是未雨绸缪,在下降的过程中,一旦遇到已满的节点(关键字个数为2t-1),就就对该节点进行分裂,这样就保证在叶子节点需要分裂时,其父节点一定是非满的,从而不需要再向上回溯。
B树的删除,delete(root, target)
在删除B树节点时,为了避免回溯,当遇到需要合并的节点时就立即执行合并,B树的删除算法如下:从root向叶子节点按照search规律遍历:
(1) 如果target在叶节点x中,则直接从x中删除target,情况(2)和(3)会保证当再叶子节点找到target时,肯定能借节点或合并成功而不会引起父节点的关键字个数少于t-1。
(2) 如果target在分支节点x中:
(a) 如果x的左分支节点y至少包含t个关键字,则找出y的最右的关键字prev,并替换target,并在y中递归删除prev。
(b) 如果x的右分支节点z至少包含t个关键字,则找出z的最左的关键字next,并替换target,并在z中递归删除next。
(c) 否则,如果y和z都只有t-1个关键字,则将targe与z合并到y中,使得y有2t-1个关键字,再从y中递归删除target。
(3) 如果关键字不在分支节点x中,则必然在x的某个分支节点p[i]中,如果p[i]节点只有t-1个关键字。
(a) 如果p[i-1]拥有至少t个关键字,则将x的某个关键字降至p[i]中,将p[i-1]的最大节点上升至x中。
(b) 如果p[i+1]拥有至少t个关键字,则将x个某个关键字降至p[i]中,将p[i+1]的最小关键字上升至x个。
(c) 如果p[i-1]与p[i+1]都拥有t-1个关键字,则将p[i]与其中一个兄弟合并,将x的一个关键字降至合并的节点中,成为中间关键字。
部分内容转自:http://blog.chinaunix.net/uid-20196318-id-3030529.html
头文件源代码
#ifndef B_TREE_H
#define B_TREE_H
#include
#include
#include
#define t 3 // the minimum degree
struct BNode
{
int size;
int key[2 * t - 1];
bool leaf;
BNode *child[2 * t];
};
std::pair BTreeSearch( BNode *node, int k );
void BTreeCreate( BNode *&T );
void BTreeSplitChild( BNode *&x, int i, BNode *&y );
void BTreeInsertNonfull( BNode *&x, int k );
void BTreeInsert( BNode *&T, int k );
void LevelOrderTraverse( BNode *T );
#endif
源代码
/**
* @brief B Tree
* @author An
* @data 2013.9.1
**/
#include "B_Tree.h"
//#include
using namespace std;
pair BTreeSearch( BNode *node, int k )
{
int i = 0;
while ( i < node->size && k > node->key[i] )
{
++i;
}
if ( i < node->size && k == node->key[i] )
{
return make_pair( node, i );
}
if ( node->leaf )
{
cout << "Search Error: No this key!" << endl;
return make_pair( node, -1 );
}
else
{
return BTreeSearch( node->child[i], k );
}
}
void BTreeCreate( BNode *&T )
{
T->size = 0;
T->leaf = true;
for ( int i = 0; i < 2 * t - 1; ++i )
{
T->key[i] = 0;
T->child[i] = NULL;
}
T->child[2 * t - 1 ] = NULL;
}
void BTreeSplitChild( BNode *&x, int i, BNode *&y )
{
// initialize the new node z
BNode *z = new BNode;
z->leaf = y->leaf;
z->size = t - 1;
for ( int j = 0; j < 2 * t - 1; ++j )
{
z->key[j] = 0;
z->child[j] = NULL;
}
z->child[2 * t - 1 ] = NULL;
for ( int j = 0; j < z->size; ++j )
{
z->key[j] = y->key[ t + j];
}
if ( !y->leaf )
{
// z->child = new BNode*[2 * t];
for ( int j = 0; j <= z->size; ++j )
{
z->child[j] = y->child[ t + j];
}
}
// update y
y->size = t - 1;
// update the children of x
for ( int j = x->size; j > i; ++j )
{
x->child[j + 1] = x->child[j];
}
x->child[i + 1] = z;
//update the keys of x
for ( int j = x->size - 1; j >= i; ++j )
{
x->key[j + 1] = x->key[j];
}
x->key[i] = y->key[ t - 1];
x->size++;
}
void BTreeInsertNonfull( BNode *&x, int k )
{
int i = x->size - 1;
if ( x->leaf )
{
while ( i >= 0 && k < x->key[i] )
{
x->key[i + 1] = x->key[i];
i--;
}
x->key[i + 1] = k;
x->size++;
}
else
{
while ( i >= 0 && k < x->key[i] )
{
i--;
}
i++;
if ( x->child[i]->size == 2 * t - 1 )
{
BTreeSplitChild( x, i, x->child[i] );
if ( k > x->key[i] )
{
i++;
}
}
BTreeInsertNonfull( x->child[i], k );
}
}
void BTreeInsert( BNode *&T, int k )
{
BNode *r = T;
if ( r->size == 2 * t - 1 )
{
BNode *s = new BNode;
s->leaf = false;
s->size = 0;
for ( int i = 0; i < 2 * t - 1; ++i )
{
s->key[i] = 0;
s->child[i] = NULL;
}
s->child[2 * t - 1 ] = NULL;
s->child[0] = r;
T = s;
BTreeSplitChild( s, 0, r );
BTreeInsertNonfull( s, k );
}
else
{
BTreeInsertNonfull( r, k );
}
}
void LevelOrderTraverse( BNode *T )
{
queue qb;
qb.push( T );
while ( !qb.empty() )
{
BNode *r = qb.front();
qb.pop();
cout << "[ ";
for ( int i = 0; i < r->size; ++i )
{
cout << r->key[i] << " ";
if ( r->child[i] != NULL )
{
qb.push( r->child[i] );
}
}
cout << "] ";
if ( r->child[r->size] != NULL )
{
qb.push( r->child[r->size] );
}
}
}
测试
#include "B_Tree.h"
int main()
{
BNode *T = new BNode;
BTreeCreate( T );
int a[] = { 18, 31, 12, 10, 15, 48, 45, 47, 50, 52, 23, 30, 20 };
int n = sizeof( a ) / sizeof( a[0] );
for ( int i = 0; i < n; ++i )
{
BTreeInsert( T, a[i] );
}
LevelOrderTraverse( T );
return 0;
}