B树学习总结

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的父节点进行统一使其不再指向v
    for(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--;//删除v
    solveUnderflow(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处的child
        rs->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)内,单次操作平均只需做常数次节点的合并