邓俊辉数据结构学习-8-2-B树
B树
概述
动机: B树实现高速I/O
640K如何"满足"任何实际需求了-- 源自比尔·盖茨的一个笑话
前提知识
- 高速缓存
- 为什么高速缓存有效?
- 不同容量的存储器,访问速度差异悬殊,磁盘和内存访问速度的量级相差\(>10^5\)
- 如果将访问内存比喻为1秒,那么访问外存则相当于1天
- 因此我们需要尽量减少IO次数
- 不同容量的存储器,访问速度差异悬殊,磁盘和内存访问速度的量级相差\(>10^5\)
- 为什么高速缓存有效?
- 分级I/O
- 俩个相邻存储级别之间的数据传输,统称为IO操作
- CPU -> RAM -> DISK -> ARRAY
- 访问速度依次递减,存储容量依次递增
- 常用的数据要放在最前面
- 从磁盘读取1B和读写1KB几乎一样快
问题:
B树为什么更宽更矮
B树实际也是BST,但是其对节点的定义方式不一样, 其定义的节点为超级节点
超级节点的概念:
如果我们将2代节点合并,并把它们都踩扁了,就会拥有4路,3个关键码
同理:每d代合并,就会拥有m =2^d路,m-1个关键码
- 多级存储系统中使用B树,可以针对外部查找,大大减少IO次数
- 对于常规BST来说,IO次数太高
- 对于AVL树来说,如果访问1G数据,10^9个关键码,一次只读取一个数据得到logN = 30 需要30次IO访问。
- 对于B树来说,则批量访问数据,一次读入一个超级节点
- 因此B树的主要目的就是为了减少IO次数
- 对于常规BST来说,IO次数太高
B树定义
- m阶B树:即m路平衡搜索树
对于m阶B树来说
关键码:
- 上限:
有不超过m-1个关键码
, 即n <= m - 1个关键码——\[ K_1 < K_2 < K_3 < ... < K_(n-1) < K_n \]
- 下限:
对于根节点来说,则只要有不少于1个关键码就行
对于其他节点来说,有不少于
\(\lceil \frac{m}{2} \rceil - 1 <= n\)个关键码
分枝数
- 上限:
有不超过m个分支
, 即n + 1 <= m个分支数——\[ A_0 < A_1 < A_2 < A_3 < ... < A_(n-1) < A_n \]
- 下限:内部节点的分支数也不能太少
对于根节点来说: 2 <= n + 1 "但树根是比较特殊的存在
对于其他节点来说:
有不少于
\(\lceil \frac{m}{2} \rceil <= n + 1\)个分支
简单举例:
- 2-4 树 —— 4阶B树,分支在2-4之内 这个树比较特殊?
- 3-5 树 —— 5阶B树,分支在3-5之内
- 3-6 树
- 4-7 树
- 4-8 树 等等
B树的性质
- 所有叶节点深度统一相等
外部节点深度统一相等
- 外部节点就是叶节点的数值为空,但不存在的孩子。
- 外部节点其实所有树都存在,但只不过我们不关心而已,但在接下来的RB?和B?,我们将比较关心这一点
important
{:.error} B树中,外部节点更加名副其实,意味着查找失败,因此需要计算外部节点
- 对于B树来说,B树的高度相对于外部节点来说。因此,空的B树高度为0,一个节点的B树高度为1。
实现
查找
一般来说,B树的词条极多,所以其存在外存之中。
B树查找的核心:只载入必需的节点,尽可能减少IO操作
{:.info}
其大概思想就是将根节点存放在内存之中,当需要某些数据时,进行B树的查找,将其从外存中读入到内存。鉴于之前
谈过的数据的局部性。我们将新的查找到的超级节点也放到内存之中。因此在同样查找的情况下,B树的树高更低,
所执行的IO次数自然就少。因此我们借助比较小的内存,就可以实现大规模数据的高效操作
实例:
- 从根节点开始, 将第一个节点的所有key读入内存之中,执行一次顺序查找,如果查找成功,直接返回,如果查找失败
按照失败位置,借助引用转向读取下一节点。 - 将下一节点的所有key读入内存之中,再次进行一次顺序查找。
...
- 到达最后的时候,如果依然失败,会进入到外部节点,此时我们认为查找失败(P.s当然,我们也可以在外部节点接入
层次更低B树,从而构成一个整体上很大的B树。
不难发现,整个B树查找的过程其实就是在顺序查找,IO操作,顺序查找,IO操作不停重复的过程。
B树的失败查找,一定结束于外部节点处。
B树的算法时间主要消耗在俩个方面
- IO上面,因此,树的高度h很重要
- 在每个超级节点上,我们都执行顺序查找(在小规模情况下,顺序查找要比二分查找快)
一个B树有N个内部节点,就一定有N+1个外部节点,从物理意义上理解,N个内部节点代表N种成功的可能,
自然对于N+1种失败的可能。
插入
对于插入来说,自然要合理使用search接口(插入必定插入在叶子节点,说实话,树的插入没有位置的选项,所以只能
插入,然后让树自己去选择位置)。search帮我们找到了叶子节点_hot,然后我们通过find接口找到
_hot节点中大于target的第一个关键码,然后在这里新插入
BTree<T>::insert(const T &e)
{auto ret = search(e);if(ret) return false; // 保证目标元素不存在++_size;// search查找失败后,_hot就是叶节点// 我们要在_hot中插入eauto retIter = find(_hot->key.begin(), _hot->key.end(), [=](T t){if(e>=t) return true;return false;}); _hot->key.insert(retIter, e);
插入关键码后,自然也要插入孩子指针,而实际上如下图所示,因为使叶子节点
我们并不需要去寻找位置,只要在child向量中push_back一个空指针即可
// 理论上的插入//int posnum = retIter - _hot->key.begin(); //_hot->child.insert(_hot->child.begin() + posnum + 1, nullptr );// 但是叶子节点后面全是外部节点,所以都是nullptr,不需要再特定位置插入 _hot->child.push_back(nullptr);// 插入之后,可能会导致这个节点的关键码超过m-1,从而溢出,违反了B树的定义。solveOverflow(_hot);
}
/*superNode-_hot ┌───┐ │ e │
┌─────────┐ ┌───┬───┬───┬───┬─┴─┬─┴─┬───┬───┐
│ key-set │───▶ │ s1│ o │ o │ o │█a█│ b │ o │ e1│
├─────────┤ ┌─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┐
│child-set│───▶│nul│nul│nul│nul│nul│NUL│nul│nul│nul│
└─────────┘ └───┴───┴───┴───┴───┴───┴───┴───┴───┘
┌─────────┐ ┌───┬───┬───┬───┬───┬───┬───┬───┬───┐
│ key-set │───▶ │ s1│ o │ o │ o │█a█│ e │ b │ o │ e1│
├─────────┤ ┌─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┐
│child-set│───▶│nul│nul│nul│nul│nul│NUL│ │nul│nul│nul│
└─────────┘ └───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘^ 这里为理论上需要插入的新节点
*/
tips
参照这幅图,我们不难发现几个规律,只要我们将key向量稍稍挪位,就可以得到一个逻辑上很清晰的关系,在秩为r的小 节点上,其左孩子在child向量中的秩r,右孩子为r + 1
插入完成之后,我们会发现这个新的B树可能会跳出去,不再符合B树的定义,我们需要使用上溢
操作将其调整回来
┌───┬───┬───┐ ┌───┬───┬───┐ ┌───┬───┬───┬───┐│400│470│500│ p->│400│470│500│ p->│400│440│470│500│└───┼───┴───┤ └───┼───┴───┤ └───┼───┼───┴───┤┌─────┘ └─┐ ┌───────┘ └─┐ ┌───┘ │ └─┐│ │ │ │ │ │ │▼ ▼ ▼ ▼ ▼ ▼ ▼┌───┬───┬───┐ ┌───┬───┬───┐ ┌───┬───┬───┬───┐ ┌───┬───┬───┐ ┌───┬───┐ ┌───┐ ┌───┬───┬───┐│410│430│450│ │520│540│570│ v->│410│430│440│450│ │520│540│570│ v->│410│430│ u->│450│ │520│540│570│└───┴───┴───┘ └───┴───┴───┘ └───┴───┴───┴───┘ └───┴───┴───┘ └───┴───┘ └───┘ └───┴───┴───┘mid┌────────────┐ ┌───────────┬───┐ ┌───────────┐│ orgin tree │ │insert node│440│ │ overflow │└────────────┘ └───────────┴───┘ └───────────┘┌───┐ │470│ ╳───╳ ╱ ╲ ╱─╱ ╲─────╲ ╱ ╲ ┌───┬───▼ ┌─▼─┐ │400│440│ │500│ └───┴───╳ └───╳ ╱ ╲ ╱────────╱ ╲ ▼ ▼
┌───┬───┬───┐ ┌───┬───┬───┐
│410│430│450│ │520│540│570│
└───┴───┴───┘ └───┴───┴───┘┌───────────┐ │ overflow │ └───────────┘
当节点发生上溢的时候,我们选取中位数,将其调整上去,然后将原来的节点分裂成俩部分
具体一点的方法就是:
- 在集和v中找到中位数440
- 让中位数右边的集独立出去(编程做法就是新建一个集和,拷贝原来,删除原来)
- 中位数升上去(利用find在p中找到大于中位数的第一个值,得到秩,有了秩就可以为所欲为了)
- 删除边角料,然后让一些小节点回指superNode
- 递归处理v的父亲p
删除
对于删除来说,同样要好好利用search接口。和之前BST的删除方法一样,B树的节点真实孩子要么为0,要么一定大于等于2
因此对于这个删除来说,必须要依然保持BST的有序性,因此就要利用节点中序后继的做法
BTree<T>::remove(const T &e)
{BTNodePos(T) v = search(e);if(!v) return false;--_size;auto rIter = find(v->key.begin(), v->key.end(), e); assert(rIter != v->key.end()); int r = rIter - v->key.begin();
在节点不是叶子节点的情况下,我们使用其中序后继,且其中序后继一定是叶子节点
if(v->child[0]) // 如果v不是叶子节点, 就交换其成为后继{BTNodePos(T) w = v->child[r + 1];while(w->child[0] ) w = w->child[0]; // 此时w就是v的后继叶子节点// 为什么? 因为在B树中,如果一个节点左子树为空,那么右子树一定为空。且其一定为叶子节点,这是定义// 而一个节点的中序后继节点没有左子树,v->key[r] = w->key[0];v = w; r = 0; } // 此时v处于最底层,删除vv->key.erase(v->key.begin()); v->child.erase(v->child.begin() + r + 1); solveUnderflow(v);return true;
}
因此,同插入一样,所有的删除一定在最底层发生
对于删除来说,因为B树的关键码下限存在,所以可能会发生下溢情况,此时我们可以通过旋转和合并来解决
y x┌───┬───┬───┐ ┌───┬───┬───┐ ┌───┬───┬───┐│400│470│500│ P │400│470│500│ P │400│450│500│└───┼───┼───┘ └───┼───┼───┘ └───┼───┼───┘┌─────┘ └┐ ┌───────┘ └─┐ ┌───────┘ └──┐│ │ │ │ │ │▼ ▼ ▼ ▼ ▼ ▼
┌───┬───┬───┐ ┌───┐ ┌───┬───┬───┐ ┌┐ ┌───┬───┐ ┌───┐
│410│430│450│ │490│ V│410│430│450│x U││ V│410│430│ U│470│y
└───┴───┴───┘ └───┘ └───┴───┴───┘ └┘ └───┴───┘ └───┘┌────────────┐ ┌───────────┬───┐ ┌───────────┐│ orgin tree │ │delete node│490│ │ rotate │└────────────┘ └───────────┴───┘ └───────────┘
这是一颗2-4树,关键码的范围为1-3
我们发现V比较富裕,V > (m -1)/2 - 1 所以向V借一个节点,V也不会发生下溢,所以U借走了P中的y,P又
借走了V中的x,看起来像发生了旋转一样
┌───┬───┬───┐ ┌───┬───┬───┐ ┌───┐ ┌───┐ ┌───┬───┐│400│470│500│ P│400│470│500│ P│400│ │500│ │400│500│└───┼───┼───┘ └───┼───┼───┘ └───┤ ├───┘ └───┼───┘┌─────┘ └┐ ┌───────┘ └─┐ ┌───────┘ └─┐ ┌──┘ │ │ │ │ │ │ │ ▼ ▼ ▼ ▼ ▼ ▼ ▼
┌───┐ ┌───┐ ┌───┐ ┌┐ ┌───┐ ┌───┐ ┌┐ ┌───┬───┐
│430│ │490│ V │430│ U││ V│430│ │470│U││ │430│450│
└───┘ └───┘ └───┘ └┘ └───┘ └───┘ └┘ └───┴───┘ ┌────────────┐ ┌───────────┬───┐ ┌───────────┬───┐ ┌───────────┐ │ orgin tree │ │delete node│490│ │down angel │490│ │ merge │ └────────────┘ └───────────┴───┘ └───────────┴───┘ └───────────┘
依然是一颗2-4树,如果之前的V已经处于崩溃边缘的话,此时就没有兄弟借钱给U了,此时就需要天使融资了。
从P中下来一个天使,这个天使节点就是U和V中间共同的老爹节点。将V和U合并,我们发现P中就会消失一个节点,
自然有连续崩溃的可能性,因此同Overflow一样,依然需要递归处理,
┌───┐ ┌───┬───┐│470│ │470│500│├───┤ ├───┼───┘ │ │ │┌─────┘ └┐ ┌───────┘ └─┐ ┌───────┘ └─┐ ┌──┘│ │ │ │ │ │ │▼ ▼ ▼ ▼ ▼ ▼ ▼
┌───┐ ┌───┐ ┌───┐ ┌┐ ┌───┐ ┌───┐ ┌┐ ┌───┬───┐
│430│ │490│ │430│ ││ │430│ │470│ ││ │430│450│
└───┘ └───┘ └───┘ └┘ └───┘ └───┘ └┘ └───┴───┘┌────────────┐ ┌───────────┬───┐ ┌───────────┬───┐ ┌───────────┐│ orgin tree │ │delete node│490│ │down angel │490│ │ merge │└────────────┘ └───────────┴───┘ └───────────┴───┘ └───────────┘
当天使节点来自根节点的时候,此时就会形成一个虚根,没有任何作用,自然直接处理掉这个虚根,
让根指向它的孩子节点。
具体的实际代码如下,
// 节点的下溢,做节点的旋转或者合并处理
template <typename T>
void
BTree<T>::solveUnderflow(BTNodePos(T) v)
{if(v->child.size() >= (_order + 1) / 2) // _order + 1) / 2 就是向上取整的操作return ; // 递归基:当前节点不满足下溢情况BTNodePos(T) p = v->parent; if(!p) // v已经是根节点,此时没有孩子的下限{if(!v->key.size() && v->child[0]){// 根节点没有关键码,却有非空孩子,此时应对根节点孩子发生合并的情况。可以直接跳过_root = v->child[0]; _root->parent = nullptr; v->child[0] = nullptr; delete v;} return ;}size_t r = 0;// 此时v中的目标节点已经被删除了,很可能不含有关键码while(p->child[r] != v) r++; // 确定v是p的第几个孩子 // 情况1: 左顾,向左兄弟借码if(r > 0) // 首先得有左兄弟{BTNodePos(T) ls = p->child[p->child.begin() + r - 1]; // v的左爹为y, ls的老幺为xif(ls->child.size() > (_order + 1) / 2) // 必须大于下限{v->key.insert(v->key.begin(), p->key[r - 1]); // v向p借一个码yp->key[r - 1] = ls->key[ls->key.size() - 1]; // p向ls借一个码xv->child.insert(v->child.begin(), ls->child[ls->child.size() - 1]);//同时将x的右孩子过继给yls->key.erase(ls->key.end() - 1); ls->child.erase(ls->child.end() - 1); if(v->child[0]) v->child[0]->parent = v; return ;} }// 情况2: 右盼,向右兄弟借码if(r < p->child.size() - 1){BTNodePos(T) rs = p->child[p->child.begin() + r + 1]; // v的右爹为y,rs的老大为xif(rs->child.size() > (_order + 1) / 2) // 右孩子足够胖,大于下限就足够胖{v->key.insert(v->key.end(), p->key[r]); // p->key[r] = rs->key[0]; v->child.insert(v->child.end(), rs->child[0]); // 将x的左孩子过继给y rs->key.erase(rs->key[0]); if(rs->child[0])rs->child[0]->parent = v; rs->child.erase(rs->child[0]); } } // 情况3: 左顾右盼失败,要么其没有左右兄弟(但不可能同时),要么左右兄弟太瘦,此时需要从上面下来一个天使, 合并if(0 < r) // 和左兄弟合并,当然也可以先和右兄弟合并,随个人喜好{BTNodePos(T) ls = p->child[r - 1]; ls->key.push_back(p->key[r - 1]);p->key.erase(p->key.begin() + r - 1); ls->child.push_back(v->child[0]); for(int i = 0; i < v->key.size(); ++i){ls->key.push_back(v->key[i]); ls->child.push_back(v->child[i+1]); } if(v->child[0]){for(int i = 0; i < v->child.size(); ++i){v->child[i]->parent = ls; delete v->child[i]; } v->child.erase(v->child.begin(), v->child.end()); } p->child.erase[p->child.begin() + r]; }else// 和右兄弟合并{BTNodePos(T) rs = p->child[r + 1]; rs->key.push_back(p->key[r]); // 把天使先合并过来p->key.erase(p->key.begin() + r); //v->child.push_back(rs->child[0]); for(int i = 0; i < rs->key.size(); ++i){v->key.push_back(rs->key[i]); v->child.push_back(rs->child[i+1]); } if(rs->child[0]){for(int i = 0; i < rs->child.size(); ++i){rs->child[i]->parent = v; delete rs->child[i]; } rs->child.erase(rs->child.begin(), rs->child.end()); } p->child.erase[p->child.begin() + r]; }solveUnderflow(p);return ;
}
B树总结
对于B树来说,可能经常遇到它,一直不太明白它比红黑树优秀在哪里。现在明白其主要功能在于减少树的高度
从而减少IO次数。
对于B树来说,主要掌握的就是其插入与删除。首先要会自己画,明白有哪些情况,然后怎么处理。知道这些后
编程只是实现而已。
- 插入:
- 因为B树的搜索知道外部节点才会停止,所以插入都是发生在最底层的叶子节点。当插入的节点超过m-1之后
就会需要重新调整。我们采取的策略是让其进行分裂,将中位关键码飞上去,然后原本的节点分为俩个关键码差不多的
节点, 依次递归调整。
- 因为B树的搜索知道外部节点才会停止,所以插入都是发生在最底层的叶子节点。当插入的节点超过m-1之后
- 删除:
- 对于删除来说,稍稍有些复杂,大致需要考虑俩个问题
- 没法生下溢之前,因为要删除节点,所以要考虑节点后面的元素怎么弥补,仍然让B树保持有序性。这里我们
采用之前BST使用的中序后继的方法,让删除统一在底层叶子节点发生。 - 发生下溢之后,节点的关键码过于少,数量低于\(\lceil \frac{m}{2} \rceil -1\),需要重新调整
- 如果左右兄弟大于\(\lceil \frac{m}{2} \rceil -1\)这个数目,就可以配合他们共同的老爹进行旋转
- 如果左右兄弟都不行,则让他们的老爹下来,将俩兄弟和老爹合并成一个新的节点。
- 没法生下溢之前,因为要删除节点,所以要考虑节点后面的元素怎么弥补,仍然让B树保持有序性。这里我们
- 对于删除来说,稍稍有些复杂,大致需要考虑俩个问题
转载于:https://www.cnblogs.com/patientcat/p/9720329.html
邓俊辉数据结构学习-8-2-B树相关推荐
- 邓俊辉数据结构学习心得系列——如何正确衡量一个算法的好坏
数据结构这门课主要关注如何设计合理的数据结构和算法,来简化时间复杂度和空间复杂度. 想要科学的解决这样一个优化的问题,最核心的思想也是最基础的,就是要量化问题.这也是将数学运用在实际问题中的一个基石. ...
- 邓俊辉数据结构学习心得系列——数据结构中所研究的算法
写在前面的话: 本文只是个人学习邓俊辉老师C++数据结构的整理,包含了很多个人的见解(从内容到材料的组织形式).所整理的内容不保证逻辑性和完整性,仅供参考. 算法的基本性质: 有正确的输入 有正确的输 ...
- 邓俊辉数据结构学习-3-栈
栈的学习 栈的应用场合 逆序输出 输出次序与处理过程颠倒,递归深度和输出长度不易预知 不是很理解 实例:进制转换 大致思路:对于进制转换,我们一般使用的都是长除法,因此要保存每次得到的余数,但是最后算 ...
- 邓俊辉数据结构学习-7-BST
二叉搜索树(Binary-Search-Tree)--BST 要求:AVL树是BBST的一个种类,继承自BST,对于AVL树,不做太多掌握要求 四种旋转,旋转是BBST自平衡的基本,变换,主要掌握旋转 ...
- 邓俊辉数据结构学习笔记3-二叉树
二叉树及其表示 树 有根树 从图论的角度看,树等价于连通无环图.因此与一般的图相同,树也由一组项点〈vertex)以及联接与其间的若干条边〈edge) 组成.在计算机科学中,往往还会在此基础上,再指定 ...
- 邓俊辉数据结构学习笔记2
列表 typedef int Rank; //秩 #define ListNodePosi(T) ListNode<T>* //列表节点位置template<typename T&g ...
- 清华邓俊辉数据结构学习笔记(4) - 二叉搜索树、高级搜索树
第七章 二叉搜索树 (a)概述 循关键码访问:数据项之间,依照各自的关键码彼此区分(call-by-key),条件是关键码之间支持大小比较与相等比对,数据集合中的数据项统一地表示和实现为词条entry ...
- 邓俊辉数据结构学习笔记1
起泡排序算法 void bubblesort1A(int A[], int n) //起泡排序算法(版本1A):0 <= n {int cmp = 0, swp = 0;bool sorted ...
- 清华邓俊辉数据结构学习笔记(3) - 二叉树、图
第五章 二叉树 (a)树 树能够结合向量的优点(search)和列表的优点(insert.remove),构成List< List >. 有根树 树是特殊的图 T = (V, E),节点数 ...
最新文章
- [物理学与PDEs]第3章习题1 只有一个非零分量的磁场
- zabbix 彻底解决图片中文乱码
- .net 使用 Aspose.Words 进行 Word替换操作
- Winform中实现对照片添加文字和图片水印(附代码下载)
- halcon测试一张图片是否过曝或过暗
- Spark源码分析:多种部署方式之间的区别与联系
- 【Flink】Flink 1.12.2 Task的调度 源码
- 题解 P1217 【[USACO1.5]回文质数 Prime Palindromes】
- Mojoportal 的用户系统
- python中time模块time函数怎么写的_Python的time模块中的常用方法整理
- 基于Leaflet 的Web地图客户端应用程序开发框架
- 如何编辑微信文章(微信文章导出word)
- 零基础学习UI设计,有哪些软件推荐
- 互联网裁员潮亲历者:那些阵痛、挣扎与去向
- STMCubeMX+Proteus仿真DHT11(LCD1602显示)
- java河南口腔医疗机构线上服务系统计算机毕业设计MyBatis+系统+LW文档+源码+调试部署
- Photoshop之旅游名片制作(保姆级教程)
- 读书笔记--推荐系统实践(2)
- phobos勒索病毒的处理,警惕phobos卷土从来
- 最近玩起了视频,把一点工作总结一下。