1.什么叫BTree?
一种适合外查找的树,它是一种平衡的多叉树,称为B树(或写成B-树,但是不能误读为“B减树”)。
2.BTree的性质
一棵M阶(M>2)的B树,是一棵平衡的M路平衡搜索树,可以是空树或者满足一下性质:
1. 根节点至少有两个孩子(孩子为NULL也算作孩子的数量)
2. 每个非根节点有[M/2,M]个孩子(注意孩子与关键字的关系,n个key,n+1孩子)
3. 每个非根节点有[M/2 - 1,M - 1]个关键字,并且以升序排列(这样才能进行查找)
4. key[i]和key[i+1]之间的孩子节点的值介于key[i]、key[i+1]之间
5. 所有的叶子节点都在同一层(整棵树的高度一致)
3.BTree结点的定义
template<class K,class V,size_t M>
//非类型的模板参数在推演时变成常量
//M阶树的孩子个数为 [M/2,M] 个孩子
//M阶树的关键字个数为 [M/2-1,M-1] 个关键字,且为升序排列
struct BTreeNode
{
//将数组的大小预留出一位是为了便于分裂
pair<K, V> _kvs[M]; //kvs数组,存放kv
BTreeNode<K, V, M>* _parent; //指向父结点的指针,便于分裂
BTreeNode<K, V, M>* _subs[M + 1]; //指向孩子结点的指针数组
size_t _size; //kvs数量,有效数据个数
BTreeNode()
:_parent(NULL)
, _size(0)
{
for (size_t i = 0; i < M + 1; i++)
{
_subs[i] = NULL;
}
}
};
4.BTree查找算法的实现
注:本来Find的返回值应该设置为bool类型,但是为了后面的插入算法实现代码的复用,返回一个pair<Node*,int>
即Node*代表该结点位置是用来插入kv的,int代表的是该位置的下标,由于没有实现multi版本,所以不允许出现重复的数据,所以当出现相同的key值时,返回make_pair(NULL,-1)。当key大于_kvs[index].first(即kvs数组的key值),应该接着往后找,直到key小于为止(如果是这种情况去_subs[index]即_kvs[index]的左孩子去找,比如图中的35)或者找不到key小于_kvs[index].first(即kvs数组的最后一个有效数据,比如图中的55),那么就应该去它最后一个位置的右孩子去找。
注:代码实现
pair<Node* ,int> Find(const K& key)
{
Node* cur = _root;
Node* parent = NULL;
size_t index = 0;
while (cur != NULL)
{
index = 0;
while (index < cur->_size)
{
if (cur->_kvs[index].first == key)
{
return make_pair(cur, -1);
}
else if (cur->_kvs[index].first > key)
{
break;
}
else
{
++index;
}
}
parent = cur;
cur = cur->_subs[index];
}
//BTree并不需要在空位置插入,一个结点可以有多个关键字
//当这个结点的孩子为空,没找到关键字时,就可以插入了
return make_pair(parent, index);
}
5.插入算法的实现
(1)首先判断树是否为空,为空新建一个结点,将pair<K,V>插入到kvs[0]中,记住把_root->_size++;
(2)首先通过Find函数找到你的数据该插入的结点的位置;
(3)在将pair<K,V>插入到当前的kvs数组,由于数组多预留了一个空间所以不会产生越界问题,每次插入数据之后记得把cur->_size++;
(4)判断当前的kvs数组的kv数量是否小于M,小于M证明当前数组插入数据之后是安全的,没有问题; 如果等于M需要进行分裂操作,将cur置成cue->parent.....重复(2)(3)(4),只不过第二部不需要通过Find函数了,中间还有许多细节问题,将会通过一个图例来说明!!!
bool Insert(const pair<K, V> & kv)
{
if (_root == NULL)
{
_root = new Node();
_root->_kvs[0] = kv;
_root->_subs[0] = NULL;
_root->_subs[1] = NULL;
_root->_size++;
}
pair<Node*, int> ret = this->Find(kv.first);
if (ret.second == -1)
return false;
//要插入位置的结点
Node* cur = ret.first;
Node* parent = cur->_parent;
Node* sub = NULL;
pair<K, V> newKV = kv;
while (1)
{
this->InsertKV(cur, newKV, sub);
if (cur->_size < M)
{
return true;
}
//走到这里表示结点存放的kv已经满了,需要分裂
Node* brother = new Node();
int mid = M / 2;
int i = mid + 1;
int j = 0;
//将中间结点之后的数据复制给兄弟结点
for (; i < M; i++)
{
brother->_kvs[j] = cur->_kvs[i];
brother->_size++;
cur->_size--;
if (cur->_subs[i] != NULL)
{
cur->_subs[i]->_parent = brother;
brother->_subs[j] = cur->_subs[i];
cur->_subs[i] = NULL;
}
j++;
}
if (cur->_subs[i] != NULL)
cur->_subs[i]->_parent = brother;
brother->_subs[j] = cur->_subs[i];
cur->_subs[i] = NULL;
//如果已经到根结点
if (parent == NULL)
{
Node* root = new Node();
root->_kvs[0] = cur->_kvs[mid];
root->_subs[0] = cur;
cur->_parent = root;
cur->_size--;
root->_subs[1] = brother;
brother->_parent = root;
_root = root;
_root->_size++;
return true;
}
//将中间结点上移
newKV = cur->_kvs[mid];
cur->_size--;
cur = parent;
parent = cur->_parent;
sub = brother;
}
}
void InsertKV(Node* cur,const pair<K, V>& kv,Node* sub)
{
size_t index = 0;
for (; index < cur->_size; index++)
{
if (kv.first < cur->_kvs[index].first)
break;
}
for (size_t i = cur->_size ; i > index; i--)
{
cur->_kvs[i] = cur->_kvs[i - 1];
cur->_subs[i + 1] = cur->_subs[i];
}
cur->_kvs[index] = kv;
cur->_subs[index + 1] = sub;
if (sub != NULL)
{
sub->_parent = cur;
}
cur->_size++;
return;
}
6.中序遍历的实现
void InOrder()
{
_InOrder(_root);
}
void _InOrder(Node* root)
{
if (root == NULL)
return;
size_t i = 0;
for (; i < root->_size; i++)
{
_InOrder(root->_subs[i]);
cout << root->_kvs[i].first << " :" << root->_kvs[i].second << endl;
}
_InOrder(root->_subs[i]);
}
7.测试用例
{ 50, 75, 139, 49, 145, 36, 101 };
{ 1, 5, 16, 17, 18, 20, 30, 35, 36, 40, 45, 46, 50, 55, 56 };
8.BTree的应用
(1)文件系统
(2)各种数据库
例如:
Windows:HPFS文件系统
Mac:HFS,HFS+文件系统
Linux:ResiserFS,XFS,Ext3FS,JFS文件系统
数据库:ORACLE,MYSQL,SQLSERVER等中
Mac:HFS,HFS+文件系统
Linux:ResiserFS,XFS,Ext3FS,JFS文件系统
数据库:ORACLE,MYSQL,SQLSERVER等中