#include "Vector.hpp" #define BTNodePosi(T) BTNode<T>* //B-树节点位置 //B-树节点模版类 template <typename T> struct BTNode{ BTNodePosi(T) parent; //父节点 Vector<T> key; //关键码向量 Vector<BTNodePosi(T)> child; //孩子向量(其长度总比key多一) BTNode() { parent = NULL; child.insert(0, NULL); } BTNode(T e,BTNodePosi(T) lc = NULL,BTNodePosi(T) rc = NULL) { parent = NULL; key.insert(0, e); child.insert(0, lc); child.insert(1, rc); //一个关键码,两个孩子 if (lc) { lc->parent = this; } if (rc) { rc -> parent = this; } } }; //B-树模版类 template <typename T> class BTree{ protected: int _size; //存放的关键码总数 int _order; //B-树的阶次,至少为3----创建时指定,一般不能修改 BTNodePosi(T) _root; //根节点 BTNodePosi(T) _hot; //BTree::search()最后访问的非空(除非树空)的节点位置 void solveOverflow(BTNodePosi(T)); //因插入而上溢之后的分裂处理 void solveUnderflow(BTNodePosi(T)); //因删除而下溢之后的合并处理 public: BTree(int order = 3) : _order(order), _size(0) { _root = new BTNode<T>(); } ~BTree() { if (_root) { delete _root; } } int const order() { return _order; } int const size() { return _size; } BTNodePosi(T) & root() { return _root; } bool empty() const { return !_root; } BTNodePosi(T) search(const T& e); bool insert(const T& e); bool remove(const T& e); }; //在B-树中查找关键码e template <typename T> BTNodePosi(T) BTree<T>::search(const T &e) { BTNodePosi(T) v = _root; _hot = NULL; while (v) { Rank r = v->key.search(e); if ( (0 <= r) && (e == v->key[r]) ) { return v; //成功:在当前节点中命中目标关键码 } _hot = v; v = v->child[r+1]; //否则,转入对应子树(_hot指向其父)---需做I/O,最费时间 }//这里在向量内是二分查找,但对通常的_order可直接顺序查找 return NULL;//失败:最终抵达外部节点 } //将关键码e插入B树中 template <typename T> bool BTree<T>::insert(const T &e) { BTNodePosi(T) v = search(e); if (v) { return false; } Rank r = _hot->key.search(e); _hot->key.insert(r+1, e); //将关键码插至对应的位置 _hot->child.insert(r+2, NULL); //创建一个空子树指针 _size++; //更新全树规模 solveOverflow(_hot); //如有必要,需做分裂 return true; //插入成功 } //关键码插入后若节点上溢,则做节点分裂处理 template <typename T> void BTree<T>::solveOverflow(BTNodePosi(T) v) { if (_order >= v->child.size()) { return; //递归基:当前节点并为上溢 } Rank s = _order / 2; //轴点(此时应有_order=key.size()=child.size()-1) BTNodePosi(T) u = new BTNode<T>(); //注意:新节点已有一个空孩子 for (Rank j = 0; j < _order-s-1; j++) { //v右侧_order-s-1个孩子及关键码分裂为右侧节点 u -> child.insert(j, v->child.remove(s+1)); //逐个移动效率低 u -> key.insert(j, v->key.remove(s+1) ); //此策略可改进 } u -> child[_order-s-1] = v->child.remove(s+1); //移动v最靠右的孩子 if (u -> child[0]) { //若u的孩子们非空,则令他们的父节点统一 for (Rank j = 0; j < _order-s; j++) { u -> child[j]->parent = u; //指向u } } BTNodePosi(T) p = v -> parent; //v当前的父节点p if (!p) { _root = p = new BTNode<T>(); p -> child[0] = v; v -> parent = p; } Rank r = 1 + p -> key.search(v -> key[0]); //p中指向u的指针的秩 p -> key.insert(r, v -> key.remove(s)); //轴点关键码上升 p -> child.insert(r + 1, u); u -> parent = p; //新节点u与父节点p互联 solveOverflow(p); //上升一层,如有必要则继续分裂-----至多递归O(logn)层 } //从BTree树中删除关键码e template <typename T> bool BTree<T>::remove(const T &e) { BTNodePosi(T) v = search(e); if (!v) { return false; } Rank r = v -> key.search(e); //确定目标关键码在节点v中的秩 if (v -> child[0]) { //若v非叶子,则e的后继必属于某叶节点 BTNodePosi(T) u = v->child[r+1]; //在右子树中一直向左,即可找出e的后继,并与之交换位置 while ( u->child[0] ) { u = u -> child[0]; } v -> key[r] = u -> key[0]; v = u; r = 0; }//至此,v必然位于最底层,且其中第r个关键码就是待删除者 //删除额,以及其下两个外部节点之一 v -> key.remove(r); v -> child.remove(r+1); _size--; solveUnderflow(v); //如有必要,需做旋转或合并 return true; } //关键码删除后若节点下溢,则做节点旋转或合并处理 template <typename T> void BTree<T>::solveUnderflow(BTNodePosi(T) v){ if ( (_order + 1 ) / 2 <= v->child.size() ) { return; } BTNodePosi(T) p = v -> parent; if (!p) { //递归基:已到根节点,没有孩子的下限 if (!v->key.size() && v->child[0]) { //但倘若作为树根的v已不包含关键码,却有(唯一的)非空孩子,则这个节点可被跳过,并因不再有用而销毁 _root = v -> child[0]; _root -> parent = NULL; v -> child[0] = NULL; delete v; } return; } Rank r = 0; while (p->child[r] != v) { r++; } //情况1:向左兄弟借关键码 if (0 < r) { BTNodePosi(T) ls = p -> child[r-1]; //左兄弟必存在 if ( (_order + 1) /2 < ls->child.size()) { //若该兄弟足够胖,则p借出一个关键码给v(作为最小关键码) v -> key.insert(0, p->key[r-1]); p -> key[r-1] = ls -> key.remove(ls->key.size()-1); v -> child.insert(0, ls->child.remove(ls->child.size() - 1)); //同时ls的最右侧孩子过继给v if (v->child[0]) { v->child[0]->parent = v; //作为v的最左侧孩子 } return; //至此,通过右旋已完成当前层(以及所有层)的下溢处理 } } //情况2:向右兄弟借关键码 if (p -> child.size() - 1 > r) { //若v不是p的最后一个孩子,则右兄弟必存在,若该兄弟足够胖 //则p借出一个关键码给v BTNodePosi(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); //ls的最小关键码转入p v -> child.insert(v->child.size(), rs->child.remove(0)); //同时rs的最左侧孩子过继给v if (v->child[v->child.size()-1]) { v->child[v->child.size()-1] -> parent = v; } return;//至此,通过左旋已完成当前层(以及所有层)的下溢处理 } } //情况3:左右兄弟要么为空(但不可能同时),要么都太"瘦" ----- 合并 if (0 < r) { //与左兄弟合并 BTNodePosi(T) ls = p->child[r-1]; //左兄弟必存在 ls->key.insert(ls->key.size(), p->key.remove(r-1)); p->child.remove(r); //p的第r-1个关键码转入ls,v不再是p的第r个孩子 ls -> child.insert(ls->child.size(), v->child.remove(0)); //v的最左侧孩子过继给ls做最右侧孩子 if (ls->child[ls->child.size()-1]) { ls->child[ls->child.size()-1] -> parent = ls; } //v剩余的关键码和孩子,一次转入ls while (!v->key.empty()) { ls->key.insert(ls->key.size(), v->key.remove(0)); ls->child.insert(ls->child.size(), v->child.remove(0)); if (ls->child[ls->child.size() - 1]) { ls->child[ls->child.size() - 1] -> parent = ls; } } delete v; }else{ //与右兄弟合并 BTNodePosi(T) rs = p -> child[r+1]; //右兄弟必存在 rs->key.insert(0, p->key.remove(r)); p->child.remove(r); //p的第r个关键码转入rs,v不再是p的第r个孩子 rs->child.insert(0, v->child.remove(v->child.size() - 1)); if (rs->child[0]) { rs->child[0] -> parent = rs; } while (!v->key.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->child[0] -> parent = rs; } } delete v; } solveUnderflow(p); // 上升一层,如有必要则继续分裂---至多递归O(logn)层 return; }