B树

多路搜索树
当数据规模足够大的时候, 大部分数据存储到外存中, 常规的平衡二叉搜索树将无法满足需求理由如下:
常规二叉平衡搜索树每当进行search(),insert(),remove()操作的时候就会进行节点的切换,从而导致大量的IO操作,就此提出了多路搜索,尝试将原本的多个节点合在一起,用于减少IO操作; 适用于在磁盘与设备上直接进行动态查找;
如下图二叉搜索及多路搜索拓扑结构:

每个节点中具有多个关键码, 每个关键码又对应着多个引用
它与二叉平衡搜索树的区别在于,将多个节点进行合并变为关键码,减少IO操作

多路搜平衡索树
m阶B-树(m>2):

• 在每个节点中具有不超过m-1个关键码, 并且外部节点(而非叶节点,包含一下为空的节点)的深度均相同;
• 每个内部节点存有不超过m-1个关键码, 每个关键码所对应的分支n不超过m个引用
• 内部节点的分支数不能太少,除根节点以外, 所有内部节点都应满足n+1>=m/2(m/2的值为向上取整), 在非空的B树中,根节点满足n>=1
• 各节点所对应的分支数介于m/2到m之间

如:(2,4) (3,5) (4,7) (4,8)树

图中空白方格则是存储指向下一层的引用(即孩子向量), 存储数字的方格则是相应的关键码向量

B树接口

//需要用到向量vector
template<typename T>class BTNode{public:BTNode<T>* parent;//父节点vector<T> key;//用于存放关键码向量vector<BTNode<T>*> child;//存放孩子向量,用于保存下一层节点地址的指针BTNode(){parent=null; child.insert(0,null);}BTNode(T e,BTNode<T>* lc=null,BTNode<T>* rc=null){parent=null;key.insert(0,e);//B树初始化,只存有一个_root,key中保存一个关键码,俩孩子child.insert(0,lc);child.insert(1,rc);if(lc) lc-parent=this;if(rc) rc->parent=this;//孩子向量的大小总是比关键码向量大小多一个}//~BTNode(){key.clear();child.clear();},析构函数待会处理
};
template<typename T>class BTREE{protected:int _size;//关键码总数int _order;//B树阶次BTNode<T>* _root,_hot;//根节点,以及进行search访问后所指向的节点位置void solveOverflow(BTNode<T>*);//节点发生上溢进行分裂void solveUnderflow(BTNode<T>*);//节点发生下溢进行合并public:BTREE(int order=3):_order(order),size(0);{_root=new BTNode<T>();}//构造函数,默认阶数为3//  ~BTREE(){if(_root)}int const order(){return _order;}int const size(){return _size;}BTNode<T>* & root(){return _root;}bool empty()const{return !_root;}//判断树根是否为空bool insert(const T& e);bool remove(const T& e);BTNode<T>* search();
};

search实现

//对比上图,思考查找方式
//查找方式与常规的二叉平衡搜索树一致,需要指出的一点是,在每个关键码中进行查找的时候若关键码较少的时候就可直接使用顺序查找策略,而非二分查找
template<typename T>BTNode<T>* BTREE<T>::search(const T& e){BTNode<T>* v=_root;_hot=null;//从根节点查找while(v){for(int i=0;i<key.size();i++){//在当前的关键码向量中顺序查找是否有满足条件的节点if(e==v.key[i])return v;else if(e<v.key[i]){//由于关键码在向量中是顺序存放,当所要查找的关键码小于key[i],i所对应的孩子引用位置就是查找的关键码下一层所在的节点位置_hot=v;//记录查找失败的节点位置v=v->child[i];}}}return null;//遍历完所有节点还未找到
}
//查找过程中总共需要访问O(logn)个节点,尽管查找过程中没有渐进上的意义,但是极大地减少了I/O操作次数,提高了访问效率

关键码插入

template<typename T>bool BTREE<T>::insert(const T& e){BTNode<T>* v=search(e); if(v) return false;//确认目标节点不存在int r=_hot->key.find(e);//find()在此处简写,需要重写find操作,查找失败返回失败的位置(这个位置是e刚好小于该关键码的位置)//在查找失败的_hot位置处的向量内定位具体e的位置,然后进行插入操作_hot->key.insert(r,e);_hot->child.insert(r+1,null);//孩子向量总是比key向量大1,所以在r+1的位置插入一个空子树指针_size++;solveOverflow(_hot);return true;//插入成功
}

由于B树在节点插入,或者节点删除时会出现当前key向量, child向量不满足B树的定义要求, 当关键码向量出现超出当前阶数所规定的最大值时,则需要进行分裂处理, 反之小于最小值则需要进行合并处理

上溢
当刚发生上溢的时候, key中恰好有m个关键码, 以m/2为分界,前后两部分为等长的的子节点, 令m/2升入上一层, 归入父节点中合适的位置, 将子节点归入m/2的左右孩子, 如此分裂后, 就可满足m阶B-树关于节点分支数的条件
例: 以37为界进行分裂上溢操作

如果将上溢的节点添加到父节点一层又导致父节点一层发生上溢操作称之为上溢的向上传递; 但是这种传递并不是没有尽头, 最远到达树根位置, 上溢操作修复之后全树的高度将上升一层(但这种概率特别低), 整个过程中所做的分裂次数必然不会超过全树的高度,即O(logn)
根据上溢过程的处理方式, 可实现如下代码:

template<typename T>void BTREE<T>::solverOverflow(BTNode* v){if(_order >= v->child.size()) return;//递归基,当前节点未发生上溢int s=_order/2;//以此为轴点向上做上溢BTNode* u=new BTNode<T>();for(int i=0;i < _order-s-1; i++){u->child.insert(i, v->child.remove(s+1));//将前半段子节点的child节点指针与原来v->child进行分裂操作,一边复制到新节点u中,一边对原来的节点的前半段子节点进行删除操作u->key.insert(i,v->key.remove(s+1));//关键码的操作与child一致//将前部分key,child逐个移动到u中}u->child[_order-s-1]=v->child.remove(s+1);//将m/2处的孩子进行移动到u中,它不能跟着m/2上溢到父节点中if(u->child[0])//如果上述操作执行了,将会把u中的child的父节点进行统一使其不再指向vfor(int j=0 ;j< _order-s; j++)u->child[j]->parent=u;BTNode<T>* p=v->parent;if(!p){//v不具有父节点,那么则要将v中m/2处的关键码通过p上升至_root的位置_root=p=new BTNode<T>();p->child[0]=v;v->parent=p;}int r=1+p->key.find(v->key[0]);//查找key[0]在p->key的位置p->key.insert(r,v->key.remove(s)));//将v中m/2上升p->child.insert(r+1,u);//将u中的child向量插入到p中u->parent=p;//u中关键码与p相连solveOverflow(p);//有必要的话,递归进行分裂直到不再上溢为止,最多O(logn)层
}

上述过程中必须要清楚v, v->child, v->parent, u, u->child, u-parent, p, p->child 之间的含义以及联系:

• v是要发生上溢的节点, v->child中存储着每个关键码的左右孩子,v->parent则是整个v节点的父亲
• u中存储着v前半段的关键码以及child, 由于u是重新申请的空间需要与p重连
• p中存储v->parent的信息以及v中上溢m/2关键码的信息,需要与v-parent, v, u, 重连

参考如下图:

关键码删除

template<typename T>bool BTREE<T>::remove(const T& e){BTNode<T>* v=search(e); if(!v) return false;//关键码未找到int r=v->key.find(e);//查找关键码在节点v中的位置if(v->child[0]){//判断是否为叶子节点,若为叶子节点则不需要将r处的v->child转移到u中BTNode<T>* u=v->child[r+1];while(u->child[0]) u=u->child[0];v->key[r]=u->key[0];v=u;r=0;//将v->child[r+1]移动至u中,完成重连,然后一路向下,找到v的直接后继,将u->key[0]把v->key[r]覆盖,使v与v->child[r+1]互换位置,v->child[r+1]代替v成为父节点 }v.key.remove(r);v->child.remove(r+1); _size--;//删除vsolveUnderflow(v);//有必要进行合并return true;
}

下溢
通过上述操作,刚好发生下溢的节点v必须恰好包含m/2-2关键码和m/2-1个分支, 可根据左右兄弟所包含关键码数目,分3中情况处理
1.v的左兄弟存在,且包含至少m/2个关键码, 右兄弟含有m/2-2个关键码:v的右兄弟向父节点p借一个关键码,使之关键码数为m/2-1, 然后父节点向v的左兄弟借一个关键码用于维持原有状态, 至此局部满足B-树的条件,整个过程可以看做是关键码之间的旋转
2. 该情况与1中的情况相反, 右兄弟存在,且包含至少m/2个关键码, 左兄弟含有m/2-2个关键码, 解决方法与1一致
3. v的左右兄弟存在或者不存在, 或者包含的关键码均不足m/2个, 解决方法可采用向父节点借一个关键码, 然后将v的左右兄弟以及借来的关键码合在一起, 此时关键码总数: (m/2-1)+1+(m/2-2)=m-2<=m-1 注:m/2做向上取整处理
上述方法完成对下溢的修复,但是有可能还会出现下溢的传递(与上溢传递情况一致); 当传递到树根的位置时,整棵树的高度将下降一层, 整个过程中至多进行O(logn)次合并操作
通过上述, 有如下代码

//整个过程中p始终代表v->parent,v代表发生下溢的向量,ls代表p在r处的左孩子,rs代表p在r处的右孩子
template<typename T>void BTREE<T>::solveUnderflow(BTNode<T>* v){if((_order+1)/2 <= v->child.size()) return;//递归基,当前节点未发生下溢BTNode<T>* p=v->parent;if(!p){//递归基,到达根节点,v代表根节点,此时的根节点已经完成了下溢的合并操作,v的内部关键码key向量已经为空if(!v->key.size() && v->child[0]){//若v中只含有child向量,key向量为空,即可以删除v,将v与_root进行重连_root=v->child[0]; _root->parent=null;v->child[0]=null]; v.clear();}return;}int r=0; while(p->child[r]!=v) r++;//确定v是p的第几个孩子,用于后续的关键码之间的三角旋转//情况1: 向左兄弟借关键码if(0<r){//v不是p的第一个孩子,说明左兄弟必然存在BTNode<T>* ls=p->child[r-1];if((_order+1)/2 < ls->child.size()){//左兄弟快发生上溢,则向左兄弟借出一个节点v->key.insert(0,p->key[r-1]);//先将p的关键码给v,再将v左兄弟的关键码给p//p借出后无需进行remove,直接通过v左兄弟的关键码将其覆盖p->key[r-1]=ls->key.remove(ls->size()-1);//由于关键码的转移,所以要将转移的关键码所对应的child进行转移v->child.insert(0,ls->child.remove(ls->child.size()-1));if(v->child[0])//判断转移后的孩子是否为空,不为空,则进行重连v->child[0]->parent=v;return;//完成当前层的下溢操作}}//情况2: 向右兄弟借关键码if(p->child.size()-1>r)//v不是p的最后一个孩子,说明右兄弟必然存在BTNode<T>* rs=p->child[r+1];if((_order+1)/2 < rs->child.size()){v.key.insert(v->key.size(),p.key[r])p->key[r]=rs->key.remove(0);v->child.insert(v->child.size(),rs->child.remove(0));if(v->child[v->key.size()-1])v->child[v->key.size()-1]->parent=v;return;}//情况3:向p中借出r位置的节点,使r的左右孩子进行合并操作if(0<r){//左兄弟存在,与左兄弟进行合并BTNode<T>* ls=p->child[r-1];//左兄弟存在,将p中r处的关键码转移至ls中ls->key.insert(ls->key.size(),p->key.remove(r-1));if(ls->child[ls->child.size()-1])//将v最左侧的孩子转移到ls中,做ls最右侧的孩子while(!v->key.empty()){//合并过程,将v中的信息全部转移至ls中ls->key.insert(ls->key.size(),v->key.remove(0));//一边对ls进行插入,一边对v进行删除ls->child.insert(ls->child.size(),v->child.remove(0));if(ls->child[ls->child.size()-1])//判断转移过来的孩子是否为空,不为空则进行child->parent与ls的重连ls->child[ls->child.size()-1]->parent=ls;}v.clear();}else{//右兄弟存在,与右兄弟合并BTNode<T>* rs=p->child[r+1];rs->key.insert(0,p->key.remove(r+1));//将p中r+1处的关键码转移至右兄弟中p->child.remove(r);//删除p中r+1处的childrs->child.insert(0,v->child.remove(v->child.size()-1));//孩子的转移if(rs->child[0])//此处做法与右兄弟中的操作一致rs->child[0]->parent=rs;while(!v->empty()){//将v中关键码,孩子向量一一转至到rs中rs->key.insert(0,v->key.remove(v->key.size()-1));rs->child.insert(0,v->child.remove(v->child.size()-1));if(rs->child[0])//rs的孩子存在,进行重连rs->child[0]->parent=rs;}v.clear();}solveUnderflow(p);//上升一层,如果有必要进行继续分裂return;
}

上述过程如下图:

删除操作的复杂度依然可以保证在O(logn)内,单次操作平均只需做常数次节点的合并