B树
可以用于查询的数据结构非常的多，比如说二插搜索树、平衡树、哈希表、位图、布隆过滤器，但如果需要存储一些数据量极大的数据，上述的数据结构就很不适用了，内存是不一定放的下的，比如用平衡树搜索一个贼大的文件。
因为数据量非常大，一次性无法加载到内存中，那么就可以在平衡树中保存数据项需要查找的部分，以及指向该数据在磁盘中的地址的指针。
虽然在上诉方法在内存中存放的是数据的地址，真实的数据是在磁盘上，解决了内存占用的问题。但是也有一定的缺陷：
- 当数据量比较大的时候，比如使用的是红黑树，虽然时间复杂度是 O ( l o g n ) O(logn) O(logn)，但数据量比较大的时候，树的高度是比较高的。
- 当数据量特别大时，树中的节点可能无法一次性加载到内存中，这就需要增加磁盘的I/O次数
解决办法：就是减少I/O的次数，降低树的高度，引入多叉平衡树(B树)
1. 概念
B树是一棵M阶(M>2)的B树，是一棵平衡的M路平衡搜索树，可以是空树或者满足一下性
质：
- 根节点至少有两个孩子
- 每个非根节点至少有
M
/
2
−
1
M/2-1
M/2−1(上取整)个关键字,至多有
M
−
1
M-1
M−1个关键字，并且以升序排列
例如：当M=3的时候，至少有3/2=1.5，向上取整等于2，2-1=1个关键字，最多是2个关键字 - 每个非根节点至少有
M
/
2
M/2
M/2(上取整)个孩子,至多有M个孩子
例如：当M=3的时候，至少有3/2=1.5，向上取整等于2个孩子。最多有3个孩子。 - key[i]和key[i+1]之间的孩子节点的值介于key[i]、key[i+1]之间
- 所有的叶子节点都在同一层
2. B树插入分析
为了简单起见，假设M = 3. 即三叉树，每个节点中存储两个数据，两个数据可以将区间分割成三个部分，因此节点应该有三个孩子，为了后续实现简单期间，节点的结构如下：
注意：孩子永远比数据多一个。
插入过程当中，有可能需要分裂，分裂的
前提是：
假设，当前是要组成一个M路查找树，关键字数必须<=M-1**（这里关键字数**>M-1就要进行节点拆分规则是：
把中间的元素，提取出来，放到父亲节点上，左边的单独构成一个节点，右边的单独构成一个节点。
假设用 53 , 139 , 75 , 49 , 145 , 36 , 101 {53,139,75,49,145,36,101} 53,139,75,49,145,36,101构造B树的过程如下：
- 先插入53和139
-
再插入75，插入75后按照插入排序的思想对元素进行排序
-
因为该节点的元素已经满了，就需要进行分裂
节点分裂的步骤：
- 找到节点数据域的中间位置
- 给一个新节点，将中间位置的数据移动到新创建的节点中
- 将中间位置的那个数据移动到父节点中
- 将节点的关系连接好
-
插入49和145
- 找到该元素的插入位置的位置
- 按照插入排序的思想将节点插入到该节点的合适位置
- 再检测是否满足B数的性质
- 满足插入结束，不满足对节点进行分裂
-
插入36
插入后违法了B树的性质，需要进行分裂
对cur节点进行分裂：
- 找到中间位置
- 将中间位置右侧元素移动到新节点中
- 将中间位置元素49移动到父节点parent中
- 将新节点的父节点修改成parent
-
插入数字101
- 在B树中找到该节点的插入位置
- 按照插入排序思想将该节点插入到指定位置
- 检测插入后的节点元素个数是否小于M
- 如果小于M插入完成，等于M则需要对该节点进行分裂
分裂完后，发现根节点也需要进行分裂，根节点分裂需要进行特殊处理，因为它会增加树的高度。
3.插入过程
-
如果树为空，直接插入新节点中，该节点为树的根节点
-
树非空，找待插入元素在树中的插入位置(注意：找到的插入节点位置一定在叶子节点中)
-
检测是否找到插入位置(假设树中的key唯一，即该元素已经存在时则不插入)
-
按照插入排序的思想将该元素插入到找到的节点中
-
检测该节点是否满足B-树的性质：即该节点中的元素个数是否等于M，如果小于则满足
-
如果插入后节点不满足B树的性质，需要对该节点进行分裂：
- 申请新节点
- 找到该节点的中间位置
- 将该节点中间位置右侧的元素以及其孩子搬移到新节点中
- 将中间位置元素以及新节点往该节点的父亲节点中插入，即继续4
-
如果向上已经分裂到根节点的位置，插入结束
4. B树插入实现
B树的节点定义
// M叉树
private static final int M = 3;
static class BTreeNode {
// 节点关键字
int[] keys;
// 孩子
BTreeNode[] subs;
// 关键字个数
int keySize;
// 父节点
BTreeNode parent;
public BTreeNode() {
keys = new int[M];
// 多给一个方便分裂
subs = new BTreeNode[M+1];
}
}
定义一个类方便查找指定节点
public class Pair<K,V> {
K key;
V val;
public Pair(K key, V val) {
this.key = key;
this.val = val;
}
}
插入代码
/**
* B树
*/
public class BTree {
// B树根节点
BTreeNode root;
public boolean insert(int key) {
if (root == null) {
root = new BTreeNode();
root.keys[0] = key;
root.keySize++;
return true;
}
// 查找关键字是否已经存在
Pair<BTreeNode,Integer> cur = find(key);
if (cur.val != -1) {
// 说明key已经存在，插入失败
return false;
}
// 开始插入(插入排序)
BTreeNode parent = cur.key;
int i = 0;
for (i = parent.keySize-1; i >= 0; i--) {
if (parent.keys[i] >= key) {
parent.keys[i+1] = parent.keys[i];
} else {
break;
}
}
parent.keys[i+1] = key;
parent.keySize++;
// 判断是否需要分裂
if (parent.keySize >= M) {
split(parent);
}
return true;
}
/**
* 对cur节点进行分裂
* @param cur
*/
private void split(BTreeNode cur) {
BTreeNode newNode = new BTreeNode();
BTreeNode parent= cur.parent;
// 中间位置
int mid = cur.keySize>>1;
// 把mid往后的元素移动到新节点
int j = 0;
int i = mid+1;
for (; i < cur.keySize; i++) {
newNode.keys[j] = cur.keys[i];
// 子节点引用
newNode.subs[j] = cur.subs[i];
// 修改子节点的parent引用
if (newNode.subs[j] != null) {
newNode.subs[j].parent = newNode;
}
newNode.keySize++;
j++;
}
// 多拷贝一次最后的子节点
newNode.subs[j] = cur.subs[i];
if (newNode.subs[j] != null) {
newNode.subs[j].parent = newNode;
}
//更新分裂节点关键字个数,-1指的是mid位置的节点要向上提
cur.keySize = cur.keySize-mid-1;
// 处理根节点分裂情况！
if (cur == root) {
root = new BTreeNode();
root.keys[0] = cur.keys[mid];
root.keySize++;
root.subs[0] = cur;
root.subs[1] = newNode;
cur.parent = root;
newNode.parent = root;
return;
}
// 更新新节点的父亲节点
newNode.parent = parent;
// 将mid位置的元素向上提
int midVal = cur.keys[mid];
i = parent.keySize-1;
for (; i >= 0; i--) {
if (parent.keys[i] >= midVal) {
parent.keys[i+1] = parent.keys[i];
parent.subs[i+2] = parent.subs[i+1];
} else {
break;
}
}
parent.keys[i+1] = midVal;
parent.keySize++;
// 将当前父节点的孩子节点设置为newNode
parent.subs[i+2] = newNode;
// 如果个数超过M递归分裂
if (parent.keySize >= M) {
split(parent);
}
}
/**
* 在B树中查找关键字是否已经存在
* 找到返回节点和起下标，否则返回其父节点和-1
* @param key
* @return
*/
private Pair<BTreeNode, Integer> find(int key) {
BTreeNode cur = root;
BTreeNode parent = root;
int index = 0;
while (cur != null) {
while (index < cur.keySize) {
if (cur.keys[index] == key) {
return new Pair<>(cur,index);
} else if (cur.keys[index] < key) {
index++;
} else {
break;
}
}
parent = cur;
// 向子节点找
cur = cur.subs[index];
index = 0;
}
return new Pair<>(parent,-1);
}
}
5.B树验证
对B树进行中序遍历，只要打印出来的数据是有序说明插入正确
/**
* 验证B树
* @param root
*/
private void inorder(BTreeNode root){
if(root == null)
return;
for(int i = 0; i < root.keySize; ++i){
inorder(root.subs[i]);
System.out.println(root.keys[i]);
}
inorder(root.subs[root.keySize]);
}
6. B树性能分析
对于一棵节点为N度的B树，查找和插入需要 l o g M − 1 N log_{M-1}N logM−1N~ l o g M / 2 N log_{M/2}N logM/2N次比较。对于度为M的B树，每一个节点的子节点个数为 M / 2 M/2 M/2~ ( M − 1 ) (M-1) (M−1)之间，因此树的高度应该要在 l o g M − 1 N log_{M-1}N logM−1N和 l o g M / 2 N log_{M/2}N logM/2N之间，在定位到该节点后，再采用二分查找的方式可以很快的定位到该元素。
B树的效率是很高的对于 N = 62 ∗ 1000000000 N=62*1000000000 N=62∗1000000000个节点，如果M为1024，则 l o g M / 2 N < = 4 log_{M/2}N<=4 logM/2N<=4，既在620亿个元素中，如果这棵树的度为1024，则需要小于4次即可定位到该节点，然后利用二分查找，可以快速定位到该元素，大大减少了读取磁盘的次数。
总结：
- B树实际上是一棵M叉平衡树
- 非根节点的关键字数量[M/2-1,M-1]，因为每次满了之后，会拷走一半
- 非根节点的孩子数量[M/2,M]
- 所有的叶子节点都在同一层，所以B树是天然平衡的
- M越大效率越高，但M越大也会有空间浪费的问题，节点分裂会拷走一半就会存在空间浪费的问题
7.B+树&B*树
B+树是B树的变形，也是一种多路搜索树：
其定义基本与B树相同，除了：
- B+树非叶子节点的子树指针与关键字个数相同，而B树的孩子数量比关键字多一个
- B+树非叶子节点的子树指针指向的子树都属于它的右子树，也就是大于当前节点
- 为所有叶子节点增加一个链指针，也就是叶子节点是一个链表
- B+数的叶子节点存储了数据，而非叶子节点只是存储了关键字。
对于B+树来说，如果要查找数据，那么一定得遍历整个树的高度，因为数据在叶子节点，但B树的每个节点都存储了数据，就不一定要遍历到叶子节点。
B+树的分裂:当一个结点满时，分配一个新的结点，
并将原结点中1/2的数据
复制到新结点，最后在父结点中增加新结点的指针，B+树的分裂只影响原结点和父
结点，而不会影响兄弟结点，所以它不需要指向兄弟的指针;
B*树
B*树是B+树的变形，在B+树的非根和非叶子节点再增加指向兄弟节点的指针。
B树的分裂:当一个结点满时，如果它的下一个兄弟结点未满，那么将一部分数据移到兄弟结点中，再在原结点插入关键字，最后修改父结点中兄弟结点的关键字(因为兄弟结点的关键字范围改变了)，如果兄弟也满了，则在原结点与兄弟结点之间增加新结点，并各复制1/3的数据到新结点，最后在父结点增加新结点的指针;所以，B*树分配新结点的概率比B+树要低，空间使用率更高;
8. 小结
- B树:多路搜索树，每个结点存储M/2到M个关键字，非叶子结点存储指向关键
字范围的子结点;所有关键字在整颗树中出现，且只出现一次，非叶子结点可以命中; - B+树:在B-树基础上，为叶子结点增加链表指针，所有关键字都在叶子结点中出现，非叶子结点作为叶子结点的索引，B+树总是到叶子结点才命中;
- B*树:在B+树基础上，为非叶子结点也增加链表指针，将结点的最低利用率从1/2提高到2/3;
9. B树的运用
B-树最常见的应用就是用来做索引。索引通俗的说就是为了方便用户快速找到所寻之物，比如：书籍目录可以让读
者快速找到相关信息，hao123网页导航网站，为了让用户能够快速的找到有价值的分类网站，本质上就是互联网
页面中的索引结构。
MySQL官方对索引的定义为：索引(index)是帮助MySQL高效获取数据的数据结构，简单来说：索引就是数据结
构。
注意：索引是基于表的，而不是基于数据库的。
MyISAM
MyISAM引擎是MySQL5.5.8版本之前默认的存储引擎，不支持事物，支持全文检索，使用B+Tree作为索引结构，
叶节点的data域存放的是数据记录的地址，其结构如下：
上图是以以Col1为主键，MyISAM的示意图，可以看出MyISAM的索引文件仅仅保存数据记录的地址**。在MyISAM中，主索引和辅助索引（Secondary key）在结构上没有任何区别，只是主索引要求key是唯一的，而辅助索引的key**可以重复。如果想在Col2上建立一个辅助索引，则此索引的结构如下图所示 ：
同样也是一棵B+Tree，data域保存数据记录的地址。因此，MyISAM中索引检索的算法为首先按照B+Tree搜索算
法搜索索引，如果指定的Key存在，则取出其data域的值，然后以data域的值为地址，读取相应数据记录。
MyISAM的索引方式也叫做**“非聚集索引”**的
InnoDB
InnoDB存储引擎支持事务，其设计目标主要面向在线事务处理的应用，从MySQL数据库5.5.8版本开始，InnoDB存储引擎是默认的存储引擎。InnoDB支持B+树索引、全文索引、哈希索引。但InnoDB使用B+Tree作为索引结构
时，具体实现方式却与MyISAM截然不同。
第一个区别是InnoDB的数据文件本身就是索引文件。MyISAM索引文件和数据文件是分离的，索引文件仅保存数据记录的地址。而InnoDB索引，表数据文件本身就是按B+Tree组织的一个索引结构，这棵树的叶节点data域保
存了完整的数据记录。这个索引的key是数据表的主键，因此InnoDB表数据文件本身就是主索引。
上图是InnoDB主索引（同时也是数据文件）的示意图，可以看到叶节点包含了完整的数据记录，这种索引叫做聚集索引。因为InnoDB的数据文件本身要按主键聚集，所以InnoDB要求表必须有主键（MyISAM可以没有），如果没有显式指定，则MySQL系统会自动选择一个可以唯一标识数据记录的列作为主键，如果不存在这种列，则MySQL自动为InnoDB表生成一个隐含字段作为主键，这个字段长度为6个字节，类型为长整形。
第二个区别是InnoDB的辅助索引data域存储相应记录主键的值而不是地址,所有辅助索引都引用主键作为data
域。
**聚集索引这种实现方式使得按主键的搜索十分高效，但是辅助索引搜索需要检索两遍索引：首先检索辅助索引获得主键，然后用主键到主索引中检索获得记录 **
10. 总结
-
像链表，顺序表这样的是否可以?
时间复杂度太高，不行
-
AVL树&红黑树是否可以?
数据量大时树的高度较高，增加了I/O次数 -
哈希表是否可以?
哈希表存在哈希冲突哈希只能支持 是或者不是。比如: where id =? 或者 where id =? 做不到范围查找: where id >10 -
为什么使用B+树，不适用B树?
- 节点点不存储data，这样一个节点就可以存储更多的key。可以使得树更矮，所以I/O操作次数更少。
- 叶子节点相连，更便于进行范围查找
聚簇索引和非聚簇索引的区别
- 聚簇索引将数据行存储在与索引相同的 B+ 树结构中，而非聚簇索引是将索引和主键 ID 存储在 B+ 树结构中；
- 数量限制不同：一张表只能有一个聚簇索引，但可以有多个非聚簇索引；
- 范围查询不同：聚簇索引中的数据行与索引行是一一对应的，因此聚簇索引通常比非聚簇索引更适合范围查询，而非聚簇索引需要进行两次查找：首先查找索引，然后查找数据行
- 非聚簇索引最大的缺点。 当查到索引对应的指针或主键后，可能还需要根据指针或主键再到数据文件或表中查询，首先检索辅助索引获得主键，然后用主键到主索引中检索获得记录
- 在Innodb下主键索引是聚集索引，在Myisam下主键索引是非聚集索引
- MyISAM 不提供事务支持。InnoDB 提供事务支持，实现了 SQL 标准定义了四个隔离级别。
- MyISAM 不支持外键，而 InnoDB 支持。
7662
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
