BTree和B+Tree详解

大家好，欢迎来到IT知识分享网。

BTree和B+Tree详解

B+树索引是B+树在数据库中的一种实现，是最常见也是数据库中使用最为频繁的一种索引。B+树中的B代表平衡(balance)，而不是二叉(binary)，因为B+树是从最早的平衡二叉树演化而来的。在讲B+树之前必须先了解二叉查找树、平衡二叉树(AVLTree)和平衡多路查找树(B-Tree)，B+树即由这些树逐步优化而来。

1、二叉查找树

二叉树的性质
二叉树具有以下性质：左子树的键值小于根的键值，右子树的键值大于根的键值。
如下图所示就是一棵二叉查找树，

对该二叉树的节点进行查找发现深度为1的节点的查找次数为1，深度为2的查找次数为2，深度为n的节点的查找次数为n，因此其平均查找次数为 (1+2+2+3+3+3) / 6 = 2.3次

二叉查找树可以任意地构造，同样是2,3,5,6,7,8这六个数字，也可以按照下图的方式来构造：

但是这棵二叉树的查询效率就低了。如:查数据节点8，至少要查询5次，而上图只需要查找3次，因此若想二叉树的查询效率尽可能高，需要这棵二叉树是平衡的，从而引出新的定义——平衡二叉树，或称AVL树。

2、平衡二叉树（AVL Tree）

平衡二叉树（AVL树）是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。也就是说在符合二叉查找树的条件下，它还满足任何节点的两个子树的高度最大差为1。
下面的两张图片，左边是AVL树，它的任何节点的两个子树的高度差<=1；右边的不是AVL树，其根节点的左子树高度为3，而右子树高度为1；

RR：RightRight，也称“右右”。插入或删除一个节点后，根节点的右孩子（Right Child）的右孩子（Right Child）还有非空节点，导致根节点的右子树高度比左子树高度高2，AVL树失去平衡。

LR：LeftRight，也称“左右”。插入或删除一个节点后，根节点的左孩子（Left Child）的右孩子（Right Child）还有非空节点，导致根节点的左子树高度比右子树高度高2，AVL树失去平衡。

RL：RightLeft，也称“右左”。插入或删除一个节点后，根节点的右孩子（Right Child）的左孩子（Left Child）还有非空节点，导致根节点的右子树高度比左子树高度高2，AVL树失去平衡。

AVL树失去平衡之后，可以通过旋转使其恢复平衡。下面分别介绍四种失去平衡的情况下对应的旋转方法。

案例1：在下面的平衡二叉树上，插入关键字83，请画出每次插入操作后得到的平衡二叉树。

插入83—>

当插入节点83后，首先可以确定不平衡的子树部分为：

—>

在插入某个节点时，若造成了某个节点不再平衡，则要做出相应的调整：有如下4中调整

LL===>右单旋

RR===>左单旋

LR===>先左旋，后右旋

RL===>先右旋，后左旋

问题一:如何确定 LL/RR/LR/RL? 先找最小不平衡子树，从最小不平衡子树的根向插入结点数两步，即可确定 

根据上图左边的，从67开始向83（插入节点）的方向，数2步。则就是先R再L，即可得到要先右旋后左旋

问题二：如何旋转呢？ 若是LR或者RL类型的调整，则针对的是最先不平衡子树的根的孩子的孩子进行旋转，则两次针对同一节点 若是RR或者LL类型的调整，则针对的是最先不平衡子树的根的孩子进行旋转 

根据上图那么就要对77进行右旋，再对77节点进行左旋

案例2：在上一个案例平衡二叉树基础上，插入63

案例3：在案例2 的基础上插入节点23

从上面的图可以看出，不管是采用二叉树还是平衡二叉树，首先都是有序的，这是它的一个优点，但是每个父节点都只有2个分支，每一个分支节点只能存储一个结果值，如果想存储更多的数据，那么意味着树要变深，这是非常影响IO的。那么可不可以采用hashmap来作为mysql数据库的索引呢？肯定也是不行的，它的缺点非常多，首先hashmap是无序的，如果是一个等值查找没什么问题?如果是一个范围查找，由于它的无序，但是查找速度非常慢。另外哈希表每次进行获取数据的时候需要进行位置运算，知道在哪一个位置下，然后再进行挨个对比，这是不可取的。红黑树其实和平衡二叉树差不多，都会导致数要变深，影响io效率。

log(N)

o(n)

3、B-Tree（平衡多路查找树）

B-Tree是为磁盘等外存储设备设计的一种平衡查找树（读作B树，不是B-树，没有B-树），因此在讲B-Tree之前了解下磁盘的相关知识。

磁盘预读：系统从磁盘读取数据到内存时是以磁盘块（block）为基本单位的，位于同一个磁盘块中的数据会被一次性读取出来，而不是需要什么取什么。InnoDB存储引擎中有页（Page）的概念，页是其磁盘管理的最小单位。InnoDB存储引擎中默认每个页的大小为16KB（16384/1024），可通过参数innodb_page_size将页的大小设置为4K、8K、16K，在MySQL中可通过如下命令查看页的大小：

mysql> show variables like 'innodb_page_size'; 

而系统一个磁盘块的存储空间往往没有这么大，因此InnoDB每次申请磁盘空间时都会是若干地址连续磁盘块来达到页的大小16KB。InnoDB在把磁盘数据读入到内存时会以页为基本单位，一般是页的整数倍，在查询数据时如果一个页中的每条数据都能有助于定位数据记录的位置，这将会减少磁盘I/O次数，提高查询效率。

B-Tree结构的数据可以让系统高效的找到数据所在的磁盘块。为了描述B-Tree，首先定义一条记录为一个二元组[key, data] ，key为记录的键值，对应表中的主键值，data为一行记录中除主键外的数据。对于不同的记录，key值互不相同。

每个节点占用一个盘块的磁盘空间，一个节点上有两个升序排序的关键字和三个指向子树根节点的指针，指针存储的是子节点所在磁盘块的地址。两个关键词划分成的三个范围域对应三个指针指向的子树的数据的范围域。以根节点为例，关键字为17和35，P1指针指向的子树的数据范围为小于17，P2指针指向的子树的数据范围为17~35，P3指针指向的子树的数据范围为大于35。

模拟查找关键字29的过程：

假如说：每个磁盘块的大小是1k（一个指针+一个数据节点是1k），那么一页就是有16个磁盘块，如果每次加载一页，也有16个指针，而且每个指针指向一个磁盘块（第二层），那么对于一个三层的b-树来说。能存储的节点数就是：16X16X16 = 4096

4、B+Tree

B+Tree是在B-Tree基础上的一种优化，InnoDB存储引擎就是用B+Tree实现其索引结构。

从上一节中的B-Tree结构图中可以看到每个节点中不仅包含数据的key值，还有data值。而每一个页的存储空间是有限的，如果data数据较大时将会导致每个节点（即一个页）能存储的key的数量很小，当存储的数据量很大时同样会导致B-Tree的深度较大，增大查询时的磁盘I/O次数，进而影响查询效率。在B+Tree中，所有数据记录节点都是按照键值大小顺序存放在同一层的叶子节点上，而非叶子节点上只存储key值信息，这样可以大大加大每个节点存储的key值数量，降低B+Tree的高度

B+树的特性：

• 所有的叶子结点中包含了全部关键字的信息，非叶子节点只存储键值信息，及指向含有这些关键字记录的指针，且叶子结点本身依关键字的大小自小而大的顺序链接，所有的非终端结点可以看成是索引部分，结点中仅含有其子树根结点中最大（或最小）关键字。 (而B树的非终节点也包含需要查找的有效信息)
• 所有叶子节点之间都有一个链指针。
• 数据记录都存放在叶子节点中。

可能上面例子中只有22条数据记录，看不出B+Tree的优点，下面做一个推算：

InnoDB存储引擎中页的大小为16KB，一般表的主键类型为INT（占用4个字节）或BIGINT（占用8个字节），指针类型也一般为4或8个字节，也就是说一个页（B+Tree中的一个节点）中大概存储16KB/(8B+8B)=1K个键值（因为是估值，为方便计算，这里的K取值为1000。也就是说一个深度为3的B+Tree索引可以维护1000 * 1000 * 50(最后一层每个磁盘块存多少数据节点，假设是50个) = 5千万条记录。深度一般是三到四层

实际情况中每个节点可能不能填充满，因此在数据库中，B+Tree的高度一般都在2-4层。mysql的InnoDB存储引擎在设计时是将根节点常驻内存的，也就是说查找某一键值的行记录时最多只需要1~3次磁盘I/O操作。

当然B+Tree的索引结构也是有缺点的，有页分裂和页合并的操作。例如：在13和15之间插入14。这就需要页分裂。

数据库中的B+Tree索引可以分为聚集索引（clustered index）和辅助索引（secondary index）。上面的B+Tree示例图在数据库中的实现即为聚集索引，聚集索引的B+Tree中的叶子节点存放的是整张表的行记录数据。辅助索引与聚集索引的区别在于辅助索引的叶子节点并不包含行记录的全部数据，而是存储相应行数据的聚集索引键，即主键。当通过辅助索引来查询数据时，InnoDB存储引擎会遍历辅助索引找到主键，然后再通过主键在聚集索引中找到完整的行记录数据

5、附录

树的代码

public class TreeNode { 
    public int val; private TreeNode left; private TreeNode right; public TreeNode(int val,TreeNode left,TreeNode right){ 
    this.val = val; this.left = left; this.right = right; } public TreeNode(int val){ 
    this.val = val; } //求二叉树的深度 public static int getDeep(TreeNode root){ 
    if(root ==null){ 
    return 0; } int leftDeep = getDeep(root.left); int rightDeep = getDeep(root.right); return leftDeep>rightDeep?leftDeep:rightDeep; } //判断二叉树是否平衡 public static boolean isBalance(TreeNode root){ 
    if(root ==null){ 
    return true; } int leftDeep = getDeep(root.left); int rightDeep = getDeep(root.right); if(Math.abs(leftDeep-rightDeep)>1){ 
    return false; } return isBalance(root.left) && isBalance(root.right); } //构建平衡二叉树 public static TreeNode toBalanceTree(TreeNode root){ 
    if(root == null) return null; root.left = toBalanceTree(root.left); root.right = toBalanceTree(root.right); int leftDeep = getDeep(root.left); int rightDeep = getDeep(root.right); if(leftDeep-rightDeep>1){ 
    //不平衡，左边深，需要右旋 System.out.println("不平衡，左边深，需要右旋"); int lld = getDeep(root.left.left); int lrd = getDeep(root.left.right); if(lrd>lld){ 
    root.left = leftRotate(root.left); } return rightRotate(root); }else if(rightDeep-leftDeep>1){ 
    //右边深，需要左旋 int rld = getDeep(root.right.left); int rrd = getDeep(root.right.right); if(rld<rrd){ 
    root.right = leftRotate(root.right); return leftRotate(root); } } return root; } //左旋 public static TreeNode leftRotate(TreeNode root){ 
    TreeNode originRoot = root; TreeNode newRoot = root.right; TreeNode tempBranch = newRoot.left; newRoot.left = originRoot; originRoot.right = tempBranch; return newRoot; } //右旋 public static TreeNode rightRotate(TreeNode root){ 
    TreeNode originRoot = root; TreeNode newRoot = root.left; TreeNode tempBranch = newRoot.right; newRoot.right = originRoot; originRoot.left = tempBranch; return newRoot; } public static void main(String[] args) { 
    TreeNode node1 = new TreeNode(4); TreeNode node2 = new TreeNode(5); TreeNode node3 = new TreeNode(6); TreeNode node4 = new TreeNode(7); TreeNode node5 = new TreeNode(8); node5.left = node4; node4.left = node3; node3.left = node2; node2.left = node1; System.out.println(isBalance(node5));//false TreeNode newRoot = toBalanceTree(node5); System.out.println(isBalance(newRoot)); System.out.println("构建完成"); } } 

磁盘基础知识-磁盘的构成

磁盘是计算机主要的存储设备，也是计算机的主要构成硬件，一切的数据都是存储在磁盘中，因此了解磁盘的结构是非常重要的。

磁盘主要构成要素有盘片、磁头、磁道、扇区、柱面，如下图。

3、磁头和柱面

磁头用于读取盘面中磁道内的扇区中存储的数据。一个盘片有上下2个盘面对应2个磁头。

柱面是所有盘面中相同磁道的柱面，形成的是一个立体的柱体形状，磁盘的柱面数和磁道数是相等的，盘面数等于总的磁头数。

3、磁盘容量计算

存储容量=磁头数磁道（柱面）数每道扇区数每扇区的字节数
比如上图共有3个盘片6个盘面（6个磁头）、7个磁道、12个扇区、每个扇区512字节
存储容量：6

712512=字节

4、磁盘读取响应时间

5、磁盘块

6、page

操作系统经常与内存和硬盘这两种存储设备进行通信，类似于“块”的概念，都需要一种虚拟的基本单位。所以，与内存操作，是虚拟一个页的概念来作为最小单位。与硬盘打交道，就是以块为最小单位。

总结

块是操作系统对硬盘读写的最小单元实际上是一种逻辑上的存储块，最终会对应到实际的物理扇区。

操作系统实际上通过建立文件的索引结构来进去文件的存取，文件的索引结构一般如下

磁盘块通过索引结构与物理扇区进行对应，分为直接索引、一级间接索引、二级间接索引、三级间接索引。

实际就是索引编号对应的内容存储的是什么的类型的问题，比如ArrayList A数据结构，A[0]存储Arraylist B，B[0]也可能存储的是Arayylist C，也就产生直接索引、一级间接索引、二级间接索引、三级间接索引等等

附上几个题目来做个练习巩固一下：

某文件系统采用多级索引结构，若磁盘块的大小为 512 字节，每个块号需占 3 字节，那么根索引采用一级索引时的文件最大长度为 （1） K 字节；采用二级索引时的文件最大长度为 （2） K 字节。

（1）512/3=170 ，一个磁盘块可以使用170个块。因此，170*512/1024=85,选A。

（2）二级索引=一级索引一级索引大小=170170512/1024=85*170=14450，选C。

例：某文件系统采用多级索引结构。若磁盘块的大小为1K字节，每个块号占3字节，那么采用二级索引时的文件最大长度为（26）K字节。

A.1024 　　B.2048 　　C. 　　D.

(1024/3)*(1024/3)*1024/1024 选C。

补充解析：就是对块存储数据进行拆分，块要么直接存储数据，要么存储的数据内容是一个索引表，索引表中每个编号都会占用空间，我自己比较容易模糊的就是，块中存储的是索引数据，还是直接的数据，直接块中存储的是具体的数据就是直接存储，块第一次存储是是索引数据就是一级所以，一级索引指向的块存储如何还是索引那就是二级索引，依次类推。