精华内容
下载资源
问答
  • 树-阶数-B+树-B树-数据库索引方式

    千次阅读 2019-11-08 16:10:06
    我们描述一颗B树时需要指定它的阶数,阶数表示了一个结点最多有多少个孩子结点,一般用字母m表示阶数。当m取2时,就是我们常见的二叉搜索树。 一颗m阶的B树定义如下: 1)每个结点最多有m-1个关键字。 2)根...

    树的阶数:

    我们描述一颗B树时需要指定它的阶数,阶数表示了一个结点最多有多少个孩子结点,一般用字母m表示阶数。当m取2时,就是我们常见的二叉搜索树。

     

    一颗m阶的B树定义如下:

    1)每个结点最多有m-1个关键字。

    2)根结点最少可以只有1个关键字。

    3)非根结点至少有Math.ceil(m/2)-1个关键字。

    4)每个结点中的关键字都按照从小到大的顺序排列,每个关键字的左子树中的所有关键字都小于它,而右子树中的所有关键字都大于它。

    5)所有叶子结点都位于同一层,或者说根结点到每个叶子结点的长度都相同。

    四阶树

    上图是一颗阶数为4的B树。在实际应用中的B树的阶数m都非常大(通常大于100),所以即使存储大量的数据,B树的高度仍然比较小。每个结点中存储了关键字(key)和关键字对应的数据(data),以及孩子结点的指针。我们将一个key和其对应的data称为一个记录但为了方便描述,除非特别说明,后续文中就用key来代替(key, value)键值对这个整体。在数据库中我们将B树(和B+树)作为索引结构,可以加快查询速速,此时B树中的key就表示键,而data表示了这个键对应的条目在硬盘上的逻辑地址。

     

    1.2 B树的插入操作

    插入操作是指插入一条记录,即(key, value)的键值对。如果B树中已存在需要插入的键值对,则用需要插入的value替换旧的value。若B树不存在这个key,则一定是在叶子结点中进行插入操作。

    1)根据要插入的key的值,找到叶子结点并插入。

    2)判断当前结点key的个数是否小于等于m-1,若满足则结束,否则进行第3步。

    3)以结点中间的key为中心分裂成左右两部分,然后将这个中间的key插入到父结点中,这个key的左子树指向分裂后的左半部分,这个key的右子支指向分裂后的右半部分,然后将当前结点指向父结点,继续进行第3步。

     

    下面以5阶B树为例,介绍B树的插入操作,在5阶B树中,结点最多有4个key,最少有2个key

    a)在空树中插入39

    clip_image002[4]

    此时根结点就一个key,此时根结点也是叶子结点


    b)继续插入22,97和41

    clip_image004

    根结点此时有4个key


    c)继续插入53

    clip_image006

    插入后超过了最大允许的关键字个数4,所以以key值为41为中心进行分裂,结果如下图所示,分裂后当前结点指针指向父结点,满足B树条件,插入操作结束。当阶数m为偶数时,需要分裂时就不存在排序恰好在中间的key,那么我们选择中间位置的前一个key或中间位置的后一个key为中心进行分裂即可。

    clip_image008


    d)依次插入13,21,40,同样会造成分裂,结果如下图所示。

    clip_image010


    e)依次插入30,27, 33 ;36,35,34 ;24,29,结果如下图所示。

    clip_image012


    f)插入key值为26的记录,插入后的结果如下图所示。

    clip_image014

    当前结点需要以27为中心分裂,并向父结点进位27,然后当前结点指向父结点,结果如下图所示。

    clip_image016

    进位后导致当前结点(即根结点)也需要分裂,分裂的结果如下图所示。

    clip_image018

    分裂后当前结点指向新的根,此时无需调整。


    g)最后再依次插入key为17,28,29,31,32的记录,结果如下图所示。

    clip_image020


    在实现B树的代码中,为了使代码编写更加容易,我们可以将结点中存储记录的数组长度定义为m而非m-1,这样方便底层的结点由于分裂向上层插入一个记录时,上层有多余的位置存储这个记录。同时,每个结点还可以存储它的父结点的引用,这样就不必编写递归程序。

    在实现B树的代码中,为了使代码编写更加容易,我们可以将结点中存储记录的数组长度定义为m而非m-1,这样方便底层的结点由于分裂向上层插入一个记录时,上层有多余的位置存储这个记录。同时,每个结点还可以存储它的父结点的引用,这样就不必编写递归程序。

    般来说,对于确定的m和确定类型的记录,结点大小是固定的,无论它实际存储了多少个记录。但是分配固定结点大小的方法会存在浪费的情况,比如key为28,29所在的结点,还有2个key的位置没有使用,但是已经不可能继续在插入任何值了,因为这个结点的前序key是27,后继key是30,所有整数值都用完了。所以如果记录先按key的大小排好序,再插入到B树中,结点的使用率就会很低,最差情况下使用率仅为50%。

    1.3 B树的删除操作

    删除操作是指,根据key删除记录,如果B树中的记录中不存对应key的记录,则删除失败。

    1)如果当前需要删除的key位于非叶子结点上,则用后继key(这里的后继key均指后继记录的意思)覆盖要删除的key,然后在后继key所在的子支中删除该后继key。此时后继key一定位于叶子结点上,这个过程和二叉搜索树删除结点的方式类似。删除这个记录后执行第2步

    2)该结点key个数大于等于Math.ceil(m/2)-1,结束删除操作,否则执行第3步。

    3)如果兄弟结点key个数大于Math.ceil(m/2)-1,则父结点中的key下移到该结点,兄弟结点中的一个key上移,删除操作结束。

    否则,将父结点中的key下移与当前结点及它的兄弟结点中的key合并,形成一个新的结点。原父结点中的key的两个孩子指针就变成了一个孩子指针,指向这个新结点。然后当前结点的指针指向父结点,重复上第2步。

    有些结点它可能即有左兄弟,又有右兄弟,那么我们任意选择一个兄弟结点进行操作即可。

    下面以5阶B树为例,介绍B树的删除操作,5阶B树中,结点最多有4个key,最少有2个key


    a)原始状态

    clip_image021


    b)在上面的B树中删除21,删除后结点中的关键字个数仍然大于等2,所以删除结束。

    clip_image023


    c)在上述情况下接着删除27。从上图可知27位于非叶子结点中,所以用27的后继替换它。从图中可以看出,27的后继为28,我们用28替换27,然后在28(原27)的右孩子结点中删除28。删除后的结果如下图所示。

    clip_image025

    删除后发现,当前叶子结点的记录的个数小于2,而它的兄弟结点中有3个记录(当前结点还有一个右兄弟,选择右兄弟就会出现合并结点的情况,不论选哪一个都行,只是最后B树的形态会不一样而已),我们可以从兄弟结点中借取一个key。所以父结点中的28下移,兄弟结点中的26上移,删除结束。结果如下图所示。

    clip_image027


    d)在上述情况下接着32,结果如下图。

    clip_image029

    当删除后,当前结点中只key,而兄弟结点中也仅有2个key。所以只能让父结点中的30下移和这个两个孩子结点中的key合并,成为一个新的结点,当前结点的指针指向父结点。结果如下图所示。

    clip_image031

    当前结点key的个数满足条件,故删除结束。


    e)上述情况下,我们接着删除key为40的记录,删除后结果如下图所示。

    clip_image033

    同理,当前结点的记录数小于2,兄弟结点中没有多余key,所以父结点中的key下移,和兄弟(这里我们选择左兄弟,选择右兄弟也可以)结点合并,合并后的指向当前结点的指针就指向了父结点。

    clip_image035

    同理,对于当前结点而言只能继续合并了,最后结果如下所示。

    clip_image037

    合并后结点当前结点满足条件,删除结束。

     

    2.B+树

    2.1 B+树的定义

    2.1 B+树的定义

    clip_image039

    各种资料上B+树的定义各有不同,一种定义方式是关键字个数和孩子结点个数相同。这里我们采取维基百科上所定义的方式,即关键字个数比孩子结点个数小1,这种方式是和B树基本等价的。上图就是一颗阶数为4的B+树。

    除此之外B+树还有以下的要求。

    1)B+树包含2种类型的结点:内部结点(也称索引结点)和叶子结点。根结点本身即可以是内部结点,也可以是叶子结点。根结点的关键字个数最少可以只有1个。

    2)B+树与B树最大的不同是内部结点不保存数据,只用于索引,所有数据(或者说记录)都保存在叶子结点中。

    3) m阶B+树表示了内部结点最多有m-1个关键字(或者说内部结点最多有m个子树),阶数m同时限制了叶子结点最多存储m-1个记录。

    4)内部结点中的key都按照从小到大的顺序排列,对于内部结点中的一个key,左树中的所有key都小于它,右子树中的key都大于等于它。叶子结点中的记录也按照key的大小排列。

    5)每个叶子结点都存有相邻叶子结点的指针,叶子结点本身依关键字的大小自小而大顺序链接。

    2.2 B+树的插入操作

    1)若为空树,创建一个叶子结点,然后将记录插入其中,此时这个叶子结点也是根结点,插入操作结束。

    2)针对叶子类型结点:根据key值找到叶子结点,向这个叶子结点插入记录。插入后,若当前结点key的个数小于等于m-1,则插入结束。否则将这个叶子结点分裂成左右两个叶子结点,左叶子结点包含前m/2个记录,右结点包含剩下的记录,将第m/2+1个记录的key进位到父结点中(父结点一定是索引类型结点),进位到父结点的key左孩子指针向左结点,右孩子指针向右结点。将当前结点的指针指向父结点,然后执行第3步。

    3)针对索引类型结点:若当前结点key的个数小于等于m-1,则插入结束。否则,将这个索引类型结点分裂成两个索引结点,左索引结点包含前(m-1)/2个key,右结点包含m-(m-1)/2个key,将第m/2个key进位到父结点中,进位到父结点的key左孩子指向左结点, 进位到父结点的key右孩子指向右结点。将当前结点的指针指向父结点,然后重复第3步。

    下面是一颗5阶B树的插入过程,5阶B数的结点最少2个key,最多4个key。

    a)空树中插入5

    clip_image041


    b)依次插入8,10,15

    clip_image043


    c)插入16

    clip_image045

    插入16后超过了关键字的个数限制,所以要进行分裂。在叶子结点分裂时,分裂出来的左结点2个记录,右边3个记录,中间key成为索引结点中的key,分裂后当前结点指向了父结点(根结点)。结果如下图所示。

    clip_image047

    当然我们还有另一种分裂方式,给左结点3个记录,右结点2个记录,此时索引结点中的key就变为15。


    d)插入17

    clip_image049


    e)插入18,插入后如下图所示

    clip_image051

    当前结点的关键字个数大于5,进行分裂。分裂成两个结点,左结点2个记录,右结点3个记录,关键字16进位到父结点(索引类型)中,将当前结点的指针指向父结点。

    clip_image053

    当前结点的关键字个数满足条件,插入结束。


    f)插入若干数据后

    clip_image055


    g)在上图中插入7,结果如下图所示

    clip_image057

    当前结点的关键字个数超过4,需要分裂。左结点2个记录,右结点3个记录。分裂后关键字7进入到父结点中,将当前结点的指针指向父结点,结果如下图所示。

    clip_image059

    当前结点的关键字个数超过4,需要继续分裂。左结点2个关键字,右结点2个关键字,关键字16进入到父结点中,将当前结点指向父结点,结果如下图所示。

    clip_image061

    当前结点的关键字个数满足条件,插入结束。

    2.3 B+树的删除操作

    如果叶子结点中没有相应的key,则删除失败。否则执行下面的步骤

    1)删除叶子结点中对应的key。删除后若结点的key的个数大于等于Math.ceil(m-1)/2 – 1,删除操作结束,否则执行第2步。

    2)若兄弟结点key有富余(大于Math.ceil(m-1)/2 – 1),向兄弟结点借一个记录,同时用借到的key替换父结(指当前结点和兄弟结点共同的父结点)点中的key,删除结束。否则执行第3步。

    3)若兄弟结点中没有富余的key,则当前结点和兄弟结点合并成一个新的叶子结点,并删除父结点中的key(父结点中的这个key两边的孩子指针就变成了一个指针,正好指向这个新的叶子结点),将当前结点指向父结点(必为索引结点),执行第4步(第4步以后的操作和B树就完全一样了,主要是为了更新索引结点)。

    4)若索引结点的key的个数大于等于Math.ceil(m-1)/2 – 1,则删除操作结束。否则执行第5步

    5)若兄弟结点有富余,父结点key下移,兄弟结点key上移,删除结束。否则执行第6步

    6)当前结点和兄弟结点及父结点下移key合并成一个新的结点。将当前结点指向父结点,重复第4步。

    注意,通过B+树的删除操作后,索引结点中存在的key,不一定在叶子结点中存在对应的记录。

    下面是一颗5阶B树的删除过程,5阶B数的结点最少2个key,最多4个key。


    a)初始状态

    clip_image063


    b)删除22,删除后结果如下图

    clip_image065

    删除后叶子结点中key的个数大于等于2,删除结束


    c)删除15,删除后的结果如下图所示

    clip_image067

    删除后当前结点只有一个key,不满足条件,而兄弟结点有三个key,可以从兄弟结点借一个关键字为9的记录,同时更新将父结点中的关键字由10也变为9,删除结束。

    clip_image069


    d)删除7,删除后的结果如下图所示

    clip_image071

    当前结点关键字个数小于2,(左)兄弟结点中的也没有富余的关键字(当前结点还有个右兄弟,不过选择任意一个进行分析就可以了,这里我们选择了左边的),所以当前结点和兄弟结点合并,并删除父结点中的key,当前结点指向父结点。

    clip_image073

    此时当前结点的关键字个数小于2,兄弟结点的关键字也没有富余,所以父结点中的关键字下移,和两个孩子结点合并,结果如下图所示。

    clip_image075

     

     

    B树与B+树的区别

     结构上的区别

    B树中关键字集合分布在整棵树中,叶节点中不包含任何关键字信息,而B+树关键字集合分布在叶子结点中,非叶节点只是叶子结点中关键字的索引; B树中任何一个关键字只出现在一个结点中,而B+树中的关键字必须出现在叶节点中,也可能在非叶结点中重复出现;

    为什么说B+树比B树更适合实际应用中操作系统的文件索引和数据库索引?

    B+树的内部节点只存储了关键字,而没有存储关键字的数据的指针,所以内部节点比B树小。那么磁盘就能加载更多的关键字信息,那么磁盘io的次数就小,而io是影响检索效率的最大因素。

    B+树的磁盘读写代价更低。B+树的内部结点并没有指向关键字具体信息的指针,其内部结点比B树小,盘块能容纳的结点中关键字数量更多,一次性读入内存中可以查找的关键字也就越多,相对的,IO读写次数也就降低了。而IO读写次数是影响索引检索效率的最大因素。

     

    B+树的查询效率更加稳定。B树搜索有可能会在非叶子结点结束,越靠近根节点的记录查找时间越短,只要找到关键字即可确定记录的存在,其性能等价于在关键字全集内做一次二分查找。而在B+树中,顺序检索比较明显,随机检索时,任何关键字的查找都必须走一条从根节点到叶节点的路,所有关键字的查找路径长度相同,导致每一个关键字的查询效率相当。 (数据库索引采用B+树的主要原因是,)B-树在提高了磁盘IO性能的同时并没有解决元素遍历的效率低下的问题。B+树的叶子节点使用指针顺序连接在一起,只要遍历叶子节点就可以实现整棵树的遍历。而且在数据库中基于范围的查询是非常频繁的,而B树不支持这样的操作(或者说效率太低)。

     

     

    因为一个索引节点就表示一个磁盘页,页的换入换出次数越多,表示磁盘IO次数越多,越低效。

     

    Q0.数据库索引有哪些,优缺点?


    hash索引和B+树索引
    hash索引等值查询效率高,但是不能排序,因此不能进行范围查询
    B+树索引数据有序,能够进行范围查询

    Q1.为什么不用二叉查找树作为数据库索引?


    二叉查找树,查找到指定数据,效率其实很高logn。但是数据库索引文件有可能很大,关系型数据存储了上亿条数据,索引文件大则上G,不可能全部放入内存中,
    而是需要的时候换入内存,方式是磁盘页。一般来说树的一个节点就是一个磁盘页。如果使用二叉查找树,那么每个节点存储一个元素,查找到指定元素,需要进行大量的磁盘IO,效率很低。
    而B树解决了这个问题,通过单一节点包含多个data,大大降低了树的高度,大大减少了磁盘IO次数。

    Q2.B树和二叉查找树的性能对比?


    B树包括B+树的设计思想都是尽可能的降低树的高度,以此降低磁盘IO的次数,因为一个索引节点就表示一个磁盘页,页的换入换出次数越多,表示磁盘IO次数越多,越低效。
    B树算法减少定位数据所在的节点时所经历的磁盘IO次数,从而加快存取速度
    假设一个节点可以容纳100个值,那么3层的B树可以容纳100万个数据。(根节点100值,第二层可以存储99个节点(k-1),也就是99*100 个值,第三层可以存储
    (99*100-1)*100)结果是近似100万个数据。而如果使用二叉查找树,则需要将近20层,也就是进行20次磁盘IO,性能差距如此之大。
    如mongoDB数据库使用,单次查询平均快于Mysql(但侧面来看Mysql至少平均查询耗时差不多)。

    Q3.B+对比B树的优点?

    (因为B树的每个节点除了存储指向子节点的索引之外,还有data域(关键字(数据的指针)),因此单一节点存储的指向子节点的索引并不是很多,树高度较高,磁盘IO次数较多,
    而B+树单一节点存储的指向子节点的索引更多,B+树空间利用率高,因此B+树高度更低,磁盘IO次数更少,性能更好。

    这段话有问题:树高度较高不对,b+树更高。正确的说法是,b+树的中间节点只存储了关键字而没有存储数据的指针,而B树既存储了关键字又存储了数据的指针,所以B+树的中间节点占用的磁盘更小,那么每个节点的磁盘叶也就小,那么磁盘就能加载更多的磁盘叶,磁盘叶交换次数更低,那么磁盘IO 就会降低。
    因为B树的中间节点存储了数据,所以整个树的每一层都有可能查找到要查找的数据,查询性能不稳定,
    而B+树所有的data都存储在叶子节点,且叶子节点位于同一层,因此查询性能稳定。
    B树如果想要进行范围查找,需要频繁的进行二叉树的中序遍历,进行范围查找比较复杂,
    B+树要查找的元素都位于叶子节点,且连接形成有序链表,便于范围查找。

    Q4.B树,B+树使用场景。


    B树主要用于文件系统,和部分数据库索引,如文档型数据库mongodb
    B+树主要用于mysql数据库索引。

    Q5.为什么数据库索引不用红黑树而用B+树?


    红黑树当插入删除元素的时候会进行频繁的变色与旋转(左旋,右旋),来保证红黑树的性质,浪费时间。
    但是当数据量较小,数据完全可以放入内存中,不需要进行磁盘IO,这时候,红黑树时间复杂度比B+树低。
    比如TreeSet TreeMap 和HashMap (jdk1.8)就是使用红黑树作为底层数据结构。

     

     

     

     

     

     

     

    展开全文
  • B+数据库中的应用

    千次阅读 2015-07-26 19:19:58
    B+数据库中的应用flyfish 2015-7-6B+数据库中的应用重要是实现索引应用方式一ID为表的主键,利用主键建立一棵B+ 叶子结点存储记录的地址 应用方式二ID为表的主键,建立一棵B+ 叶子结点存储了整条记录

    B+树在数据库中的应用

    flyfish 2015-7-6

    B+树在数据库中的应用重要是实现索引

    应用方式一

    ID为表的主键,利用主键建立一棵B+树
    叶子结点存储记录的地址
    这里写图片描述

    应用方式二

    ID为表的主键,建立一棵B+树
    叶子结点存储了整条记录
    这里写图片描述

    展开全文
  • B树数据库的结合

    千次阅读 2012-12-06 16:56:23
    B- 1 .B-定义 B-是一种平衡的多路查找,它在文件系统中很有用。 定义:一棵m 阶的B-,或者为空,或为满足下列特性的m 叉: ⑴中每个结点至多有m 棵子树; ⑵若根结点不是叶子结点,...

    B-树

    1 .B-树定义

    B-树是一种平衡的多路查找树,它在文件系统中很有用。

    定义:一棵m 阶的B-树,或者为空树,或为满足下列特性的m 叉树:
    ⑴树中每个结点至多有m 棵子树;
    ⑵若根结点不是叶子结点,则至少有两棵子树;

    ⑶除根结点之外的所有非终端结点至少有[m/2] 棵子树;
    ⑷所有的非终端结点中包含以下信息数据:

          (n,A0,K1,A1,K2,…,Kn,An)
    其中:Ki(i=1,2,…,n)为关键码,且Ki<Ki+1,

               Ai 为指向子树根结点的指针(i=0,1,…,n),且指针Ai-1 所指子树中所有结点的关键码均小于Ki (i=1,2,…,n),An 所指子树中所有结点的关键码均大于Kn.

               n   为关键码的个数。
    ⑸所有的叶子结点都出现在同一层次上,并且不带信息(可以看作是外部结点或查找失败的结点,实际上这些结点不存在,指向这些结点的指针为空)。

       即所有叶节点具有相同的深度,等于树高度。

     如一棵四阶B-树,其深度为4.

              


    B-树的查找类似二叉排序树的查找,所不同的是B-树每个结点上是多关键码的有序表,在到达某个结点时,先在有序表中查找,若找到,则查找成功;否则,到按照对应的指针信息指向的子树中去查找,当到达叶子结点时,则说明树中没有对应的关键码。

    在上图的B-树上查找关键字47的过程如下:

    1)首先从更开始,根据根节点指针找到 *节点,因为 *a 节点中只有一个关键字,且给定值47 > 关键字35,则若存在必在指针A1所指的子树内。

    2)顺指针找到 *c节点,该节点有两个关键字(43和 78),而43 < 47 < 78,若存在比在指针A1所指的子树中。

    3)同样,顺指针找到 *g节点,在该节点找到关键字47,查找成功。

    2. 查找算法

    1. typedef int KeyType ;  
    2. #define m 5                 /*B 树的阶,暂设为5*/   
    3. typedef struct Node{  
    4.     int keynum;             /* 结点中关键码的个数,即结点的大小*/  
    5.     struct Node *parent;    /*指向双亲结点*/   
    6.     KeyType key[m+1];       /*关键码向量,0 号单元未用*/   
    7.     struct Node *ptr[m+1];  /*子树指针向量*/   
    8.     Record *recptr[m+1];    /*记录指针向量*/  
    9. }NodeType;                  /*B 树结点类型*/  
    10.   
    11. typedef struct{  
    12.     NodeType *pt;           /*指向找到的结点*/  
    13.     int i;                  /*在结点中的关键码序号,结点序号区间[1…m]*/  
    14.     int tag;                /* 1:查找成功,0:查找失败*/  
    15. }Result;                    /*B 树的查找结果类型*/  
    16.   
    17. Result SearchBTree(NodeType *t,KeyType kx)  
    18. {   
    19.     /*在m 阶B 树t 上查找关键码kx,反回(pt,i,tag)。若查找成功,则特征值tag=1,*/  
    20.     /*指针pt 所指结点中第i 个关键码等于kx;否则,特征值tag=0,等于kx 的关键码记录*/  
    21.     /*应插入在指针pt 所指结点中第i 个和第i+1 个关键码之间*/  
    22.     p=t;q=NULL;found=FALSE;i=0; /*初始化,p 指向待查结点,q 指向p 的双亲*/  
    23.     while(p&&!found)  
    24.     {   n=p->keynum;i=Search(p,kx);          /*在p-->key[1…keynum]中查找*/  
    25.         if(i>0&&p->key[i]= =kx) found=TRUE; /*找到*/  
    26.         else {q=p;p=p->ptr[i];}  
    27.     }  
    28.     if(found) return (p,i,1);               /*查找成功*/  
    29.     else return (q,i,0);                    /*查找不成功,反回kx 的插入位置信息*/  
    30. }  
    1. typedef int KeyType ;  
    2. #define m 5                 /*B 树的阶,暂设为5*/  
    3. typedef struct Node{  
    4.     int keynum;             /* 结点中关键码的个数,即结点的大小*/  
    5.     struct Node *parent;    /*指向双亲结点*/   
    6.     KeyType key[m+1];       /*关键码向量,0 号单元未用*/   
    7.     struct Node *ptr[m+1];  /*子树指针向量*/   
    8.     Record *recptr[m+1];    /*记录指针向量*/  
    9. }NodeType;                  /*B 树结点类型*/  
    10.   
    11. typedef struct{  
    12.     NodeType *pt;           /*指向找到的结点*/  
    13.     int i;                  /*在结点中的关键码序号,结点序号区间[1…m]*/  
    14.     int tag;                /* 1:查找成功,0:查找失败*/  
    15. }Result;                    /*B 树的查找结果类型*/  
    16.   
    17. Result SearchBTree(NodeType *t,KeyType kx)  
    18. {   
    19.     /*在m 阶B 树t 上查找关键码kx,反回(pt,i,tag)。若查找成功,则特征值tag=1,*/  
    20.     /*指针pt 所指结点中第i 个关键码等于kx;否则,特征值tag=0,等于kx 的关键码记录*/  
    21.     /*应插入在指针pt 所指结点中第i 个和第i+1 个关键码之间*/  
    22.     p=t;q=NULL;found=FALSE;i=0; /*初始化,p 指向待查结点,q 指向p 的双亲*/  
    23.     while(p&&!found)  
    24.     {   n=p->keynum;i=Search(p,kx);          /*在p-->key[1…keynum]中查找*/  
    25.         if(i>0&&p->key[i]= =kx) found=TRUE; /*找到*/  
    26.         else {q=p;p=p->ptr[i];}  
    27.     }  
    28.     if(found) return (p,i,1);               /*查找成功*/  
    29.     else return (q,i,0);                    /*查找不成功,反回kx 的插入位置信息*/  
    30. }  

     

    B- 树查找算法分析

    从查找算法中可以看出, 在B- 树中进行查找包含两种基本操作:

            ( 1) 在B- 树中查找结点;

            ( 2) 在结点中查找关键字。

           由于B- 树通常存储在磁盘上, 则前一查找操作是在磁盘上进行的, 而后一查找操作是在内存中进行的, 即在磁盘上找到指针p 所指结点后, 先将结点中的信息读入内存, 然后再利用顺序查找或折半查找查询等于K 的关键字。显然, 在磁盘上进行一次查找比在内存中进行一次查找的时间消耗多得多.

          因此, 在磁盘上进行查找的次数、即待查找关键字所在结点在B- 树上的层次树, 是决定B树查找效率的首要因素

            那么,对含有n 个关键码的m 阶B-树,最坏情况下达到多深呢?可按二叉平衡树进行类似分析。首先,讨论m 阶B-数各层上的最少结点数。

           由B树定义:B树包含n个关键字。因此有n+1个树叶都在第J+1 层。

        1)第一层为根,至少一个结点,根至少有两个孩子,因此在第二层至少有两个结点。

        2)除根和树叶外,其它结点至少有[m/2]个孩子,因此第三层至少有2*[m/2]个结点,在第四层至少有2*[m/2]2 个结点…

        3)那么在第J+1层至少有2*[m/2]J-1个结点,而J+1层的结点为叶子结点,于是叶子结点的个数n+1。有:

              

            也就是说在n个关键字的B树查找,从根节点到关键字所在的节点所涉及的节点数不超过:

          

    3.B-树的插入

      B-树的生成也是从空树起,逐个插入关键字而得。但由于B-树结点中的关键字个数必须≥ceil(m/2)-1,因此,每次插入一个关键字不是在树中添加一个叶子结点,而是首先在最低层的某个非终端结点中添加一个关键字,若该结点的关键字个数不超过m-1,则插入完成,否则要产生结点的“分裂”,

    如图(a) 为3阶的B-树(图中略去F结点(即叶子结点)),假设需依次插入关键字30,26,85。



    1) 首先通过查找确定插入的位置。由根*a 起进行查找,确定30应插入的在*d 节点中。由于*d 中关键字数目不超过2(即m-1),故第一个关键字插入完成:如(b)


    2) 同样,通过查找确定关键字26亦应插入 *d. 由于*d节点关键字数目超过2,此时需要将 *d分裂成两个节点,关键字26及其前、后两个指针仍保留在 *d 节点中,而关键字37 及其前、后两个指针存储到新的产生的节点 *d` 中。同时将关键字30 和指示节点 *d `的指针插入到其双亲的节点中。由于 *b节点中的关键字数目没有超过2,则插入完成.如(c)(d)




    3) (e) -(g) 为插入85后;


    插入算法:

    1. int InserBTree(NodeType **t,KeyType kx,NodeType *q,int i){   
    2.     /* 在m 阶B 树*t 上结点*q 的key[i],key[i+1]之间插入关键码kx*/   
    3.     /*若引起结点过大,则沿双亲链进行必要的结点分裂调整,使*t仍为m 阶B 树*/  
    4.     x=kx;ap=NULL;finished=FALSE;  
    5.     while(q&&!finished)  
    6.     {   
    7.         Insert(q,i,x,ap);               /*将x 和ap 分别插入到q->key[i+1]和q->ptr[i+1]*/  
    8.         if(q->keynum<m) finished=TRUE;    /*插入完成*/  
    9.         else  
    10.         {                               /*分裂结点*p*/  
    11.             s=m/2;split(q,ap);x=q->key[s];  
    12.             /*将q->key[s+1…m],q->ptr[s…m]和q->recptr[s+1…m]移入新结点*ap*/  
    13.             q=q->parent;  
    14.             if(q) i=Search(q,kx); /*在双亲结点*q 中查找kx 的插入位置*/  
    15.         }  
    16.     }  
    17.     if(!finished)           /*(*t)是空树或根结点已分裂为*q*和ap*/  
    18.     NewRoot(t,q,x,ap); /*生成含信息(t,x,ap)的新的根结点*t,原*t 和ap 为子树指针*/  
    19. }  
    1. int InserBTree(NodeType **t,KeyType kx,NodeType *q,int i){   
    2.     /* 在m 阶B 树*t 上结点*q 的key[i],key[i+1]之间插入关键码kx*/   
    3.     /*若引起结点过大,则沿双亲链进行必要的结点分裂调整,使*t仍为m 阶B 树*/  
    4.     x=kx;ap=NULL;finished=FALSE;  
    5.     while(q&&!finished)  
    6.     {   
    7.         Insert(q,i,x,ap);               /*将x 和ap 分别插入到q->key[i+1]和q->ptr[i+1]*/  
    8.         if(q->keynum<m) finished=TRUE;    /*插入完成*/  
    9.         else  
    10.         {                               /*分裂结点*p*/  
    11.             s=m/2;split(q,ap);x=q->key[s];  
    12.             /*将q->key[s+1…m],q->ptr[s…m]和q->recptr[s+1…m]移入新结点*ap*/  
    13.             q=q->parent;  
    14.             if(q) i=Search(q,kx); /*在双亲结点*q 中查找kx 的插入位置*/  
    15.         }  
    16.     }  
    17.     if(!finished)           /*(*t)是空树或根结点已分裂为*q*和ap*/  
    18.     NewRoot(t,q,x,ap); /*生成含信息(t,x,ap)的新的根结点*t,原*t 和ap 为子树指针*/  
    19. }  


    4. B-树的删除

          反之,若在B-树上删除一个关键字,则首先应找到该关键字所在结点,并从中删除之,若该结点为最下层的非终端结点,且其中的关键字数目不少于ceil(m/2),则删除完成,否则要进行“合并”结点的操作。假若所删关键字为非终端结点中的Ki,则可以指针Ai所指子树中的最小关键字Y替代Ki,然后在相应的结点中删去Y。例如,在下图  图4.1( a)的B-树上删去45,可以*f结点中的50替代45,然后在*f结点中删去50。


                                    图4.1( a)

    因此,下面我们可以只需讨论删除最下层非终端结点中的关键字的情形。有下列三种可能:

        (1)被删关键字所在结点中的关键字数目不小于ceil(m/2),则只需从该结点中删去该关键字Ki和相应指针Ai,树的其它部分不变,例如,从图  图4.1( a)所示B-树中删去关键字12,删除后的B-树如图  图4.2( a)所示:


                               图4.2( a)

       (2)被删关键字所在结点中的关键字数目等于ceil(m/2)-1,而与该结点相邻的右兄弟(或左兄弟)结点中的关键字数目大于ceil(m/2)-1,则需将其兄弟结点中的最小(或最大)的关键字上移至双亲结点中,而将双亲结点中小于(或大于)且紧靠该上移关键字的关键字下移至被删关键字所在结点中。

    [例如],从图图4.2( a)中删去50,需将其右兄弟结点中的61上移至*e结点中,而将*e结点中的53移至*f,从而使*f和*g中关键字数目均不小于ceil(m-1)-1,而双亲结点中的关键字数目不变,如图图4.2(b)所示。


                                   图4.2(b)

           (3)被删关键字所在结点和其相邻的兄弟结点中的关键字数目均等于ceil(m/2)-1。假设该结点有右兄弟,且其右兄弟结点地址由双亲结点中的指针Ai所指,则在删去关键字之后,它所在结点中剩余的关键字和指针,加上双亲结点中的关键字Ki一起,合并到 Ai所指兄弟结点中(若没有右兄弟,则合并至左兄弟结点中)。

    [例如],从图4.2(b)所示 B-树中删去53,则应删去*f结点,并将*f中的剩余信息(指针“空”)和双亲*e结点中的 61一起合并到右兄弟结点*g中。删除后的树如图4.2(c)所示。

     

                                    图4.2(c)

     如果因此使双亲结点中的关键字数目小于ceil(m/2)-1,则依次类推。

    [例如],在 图4.2(c)的B-树中删去关键字37之后,双亲b结点中剩余信息(“指针c”)应和其双亲*a结点中关键字45一起合并至右兄弟结点*e中,删除后的B-树如图 4.2(d)所示。  

                             图 4.2(d)


    B-树主要应用在文件系统

    为了将大型数据库文件存储在硬盘上 以减少访问硬盘次数为目的 在此提出了一种平衡多路查找树——B-树结构 由其性能分析可知它的检索效率是相当高的 为了提高 B-树性能’还有很多种B-树的变型,力图对B-树进行改进


    B+树

          B+树是应文件系统所需而产生的一种B-树的变形树。一棵m 阶的B+树和m 阶的B-
    树的差异在于:
    ⑴有n 棵子树的结点中含有n 个关键码;
    ⑵所有的叶子结点中包含了全部关键码的信息,及指向含有这些关键码记录的指针,且
    叶子结点本身依关键码的大小自小而大的顺序链接。
    ⑶所有的非终端结点可以看成是索引部分,结点中仅含有其子树根结点中最大(或最小)关键码。

     如图一棵3阶的B+树:


    通常在B+树上有两个头指针,一个指向根节点,另一个指向关键字最小的叶子节点。因此可以对B+树进行两种查找运算:一种是从最小关键字起顺序查找,另一种是从根节点开始,进行随机查找。 
    在B+树上进行随机查找、插入和删除的过程基本上与B-树类似。只是在查找时,若非终端结点上的关键码等于给定值,并不终止,而是继续向下直到叶子结点。因此,在B+
    树,不管查找成功与否,每次查找都是走了一条从根到叶子结点的路径。

    B+树在数据库中的应用

    1. 索引在数据库中的作用 

            在数据库系统的使用过程当中,数据的查询是使用最频繁的一种数据操作。

            最基本的查询算法当然是顺序查找(linear search),遍历表然后逐行匹配行值是否等于待查找的关键字,其时间复杂度为O(n)。但时间复杂度为O(n)的算法规模小的表,负载轻的数据库,也能有好的性能。  但是数据增大的时候,时间复杂度为O(n)的算法显然是糟糕的,性能就很快下降了。

           好在计算机科学的发展提供了很多更优秀的查找算法,例如二分查找(binary search)、二叉树查找(binary tree search)等。如果稍微分析一下会发现,每种查找算法都只能应用于特定的数据结构之上,例如二分查找要求被检索数据有序,而二叉树查找只能应用于二叉查找树上,但是数据本身的组织结构不可能完全满足各种数据结构(例如,理论上不可能同时将两列都按顺序进行组织),所以,在数据之外,数据库系统还维护着满足特定查找算法的数据结构,这些数据结构以某种方式引用(指向)数据,这样就可以在这些数据结构上实现高级查找算法。这种数据结构,就是索引。

           索引是对数据库表 中一个或多个列的值进行排序的结构。与在表 中搜索所有的行相比,索引用指针 指向存储在表中指定列的数据值,然后根据指定的次序排列这些指针,有助于更快地获取信息。通常情 况下 ,只有当经常查询索引列中的数据时 ,才需要在表上创建索引。索引将占用磁盘空间,并且影响数 据更新的速度。但是在多数情况下 ,索引所带来的数据检索速度优势大大超过它的不足之处。

    2. B+树在数据库索引中的应用


    目前大部分数据库系统及文件系统都采用B-Tree或其变种B+Tree作为索引结构

    1)在数据库索引的应用

    在数据库索引的应用中,B+树按照下列方式进行组织   :

    ①  叶结点的组织方式 。B+树的查找键 是数据文件的主键 ,且索引是稠密的。也就是说 ,叶结点 中为数据文件的第一个记录设有一个键、指针对 ,该数据文件可以按主键排序,也可以不按主键排序 ;数据文件按主键排序,且 B +树是稀疏索引 ,  在叶结点中为数据文件的每一个块设有一个键、指针对 ;数据文件不按键属性排序 ,且该属性是 B +树 的查找键 , 叶结点中为数据文件里出现的每个属性K设有一个键 、 指针对 , 其中指针执行排序键值为 K的 记录中的第一个。

    ② 非叶结点 的组织方式。B+树 中的非叶结点形成 了叶结点上的一个多级稀疏索引。  每个非叶结点中至少有ceil( m/2 ) 个指针 , 至多有 m 个指针 。  

    2)B+树索引的插入和删除

    ①在向数据库中插入新的数据时,同时也需要向数据库索引中插入相应的索引键值 ,则需要向 B+树 中插入新的键值。即上面我们提到的B-树插入算法。

    ②当从数据库中删除数据时,同时也需要从数据库索引中删除相应的索引键值 ,则需要从 B+树 中删 除该键值 。即B-树删除算法

    为什么使用B-Tree(B+Tree)

         二叉查找树进化品种的红黑树等数据结构也可以用来实现索引,但是文件系统及数据库系统普遍采用B-/+Tree作为索引结构。

     一般来说,索引本身也很大,不可能全部存储在内存中,因此索引往往以索引文件的形式存储的磁盘上。这样的话,索引查找过程中就要产生磁盘I/O消耗,相对于内存存取,I/O存取的消耗要高几个数量级,所以评价一个数据结构作为索引的优劣最重要的指标就是在查找过程中磁盘I/O操作次数的渐进复杂度。换句话说,索引的结构组织要尽量减少查找过程中磁盘I/O的存取次数。为什么使用B-/+Tree,还跟磁盘存取原理有关。

           局部性原理与磁盘预读

      由于存储介质的特性,磁盘本身存取就比主存慢很多,再加上机械运动耗费,磁盘的存取速度往往是主存的几百分分之一,因此为了提高效率,要尽量减少磁盘I/O。为了达到这个目的,磁盘往往不是严格按需读取,而是每次都会预读,即使只需要一个字节,磁盘也会从这个位置开始,顺序向后读取一定长度的数据放入内存。这样做的理论依据是计算机科学中著名的局部性原理:

      当一个数据被用到时,其附近的数据也通常会马上被使用。

      程序运行期间所需要的数据通常比较集中。

      由于磁盘顺序读取的效率很高(不需要寻道时间,只需很少的旋转时间),因此对于具有局部性的程序来说,预读可以提高I/O效率。

      预读的长度一般为页(page)的整倍数。页是计算机管理存储器的逻辑块,硬件及操作系统往往将主存和磁盘存储区分割为连续的大小相等的块,每个存储块称为一页(在许多操作系统中,页得大小通常为4k),主存和磁盘以页为单位交换数据。当程序要读取的数据不在主存中时,会触发一个缺页异常,此时系统会向磁盘发出读盘信号,磁盘会找到数据的起始位置并向后连续读取一页或几页载入内存中,然后异常返回,程序继续运行。

     

          我们上面分析B-/+Tree检索一次最多需要访问节点:

         h =

        

          数据库系统巧妙利用了磁盘预读原理,将一个节点的大小设为等于一个页,这样每个节点只需要一次I/O就可以完全载入。为了达到这个目的,在实际实现B- Tree还需要使用如下技巧:

          每次新建节点时,直接申请一个页的空间,这样就保证一个节点物理上也存储在一个页里,加之计算机存储分配都是按页对齐的,就实现了一个node只需一次I/O。

      B-Tree中一次检索最多需要h-1次I/O(根节点常驻内存),渐进复杂度为O(h)=O(logmN)。一般实际应用中,m是非常大的数字,通常超过100,因此h非常小(通常不超过3)。

      综上所述,用B-Tree作为索引结构效率是非常高的。

      而红黑树这种结构,h明显要深的多。由于逻辑上很近的节点(父子)物理上可能很远,无法利用局部性,所以红黑树的I/O渐进复杂度也为O(h),效率明显比B-Tree差很多。

     

    MySQL的B-Tree索引(技术上说B+Tree)

           在 MySQL 中,主要有四种类型的索引,分别为: B-Tree 索引, Hash 索引, Fulltext 索引和 R-Tree 索引。我们主要分析B-Tree 索引。

            B-Tree 索引是 MySQL 数据库中使用最为频繁的索引类型,除了 Archive 存储引擎之外的其他所有的存储引擎都支持 B-Tree 索引。Archive 引擎直到 MySQL 5.1 才支持索引,而且只支持索引单个 AUTO_INCREMENT 列。

           不仅仅在 MySQL 中是如此,实际上在其他的很多数据库管理系统中B-Tree 索引也同样是作为最主要的索引类型,这主要是因为 B-Tree 索引的存储结构在数据库的数据检索中有非常优异的表现。

         一般来说, MySQL 中的 B-Tree 索引的物理文件大多都是以 Balance Tree 的结构来存储的,也就是所有实际需要的数据都存放于 Tree 的 Leaf Node(叶子节点) ,而且到任何一个 Leaf Node 的最短路径的长度都是完全相同的,所以我们大家都称之为 B-Tree 索引。当然,可能各种数据库(或 MySQL 的各种存储引擎)在存放自己的 B-Tree 索引的时候会对存储结构稍作改造。如 Innodb 存储引擎的 B-Tree 索引实际使用的存储结构实际上是 B+Tree,也就是在 B-Tree 数据结构的基础上做了很小的改造,在每一个Leaf Node 上面出了存放索引键的相关信息之外,还存储了指向与该 Leaf Node 相邻的后一个 LeafNode 的指针信息(增加了顺序访问指针),这主要是为了加快检索多个相邻 Leaf Node 的效率考虑。

     

    下面主要讨论MyISAM和InnoDB两个存储引擎的索引实现方式:

    1. MyISAM索引实现:

    1)主键索引:

    MyISAM引擎使用B+Tree作为索引结构,叶节点的data域存放的是数据记录的地址。下图是MyISAM主键索引的原理图:


                                                                               (图myisam1)

    这里设表一共有三列,假设我们以Col1为主键,图myisam1是一个MyISAM表的主索引(Primary key)示意。可以看出MyISAM的索引文件仅仅保存数据记录的地址。

    2)辅助索引(Secondary key)

    在MyISAM中,主索引和辅助索引(Secondary key)在结构上没有任何区别,只是主索引要求key是唯一的,而辅助索引的key可以重复。如果我们在Col2上建立一个辅助索引,则此索引的结构如下图所示:
      

     

    同样也是一颗B+Tree,data域保存数据记录的地址。因此,MyISAM中索引检索的算法为首先按照B+Tree搜索算法搜索索引,如果指定的Key存在,则取出其data域的值,然后以data域的值为地址,读取相应数据记录。

    MyISAM的索引方式也叫做“非聚集”的,之所以这么称呼是为了与InnoDB的聚集索引区分。

     

    2. InnoDB索引实现

    然InnoDB也使用B+Tree作为索引结构,但具体实现方式却与MyISAM截然不同.

    1)主键索引:

             MyISAM索引文件和数据文件是分离的,索引文件仅保存数据记录的地址。而在InnoDB中,表数据文件本身就是按B+Tree组织的一个索引结构,这棵树的叶节点data域保存了完整的数据记录。这个索引的key是数据表的主键,因此InnoDB表数据文件本身就是主索引。

                   (图inndb主键索引)

     

     

    (图inndb主键索引)是InnoDB主索引(同时也是数据文件)的示意图,可以看到叶节点包含了完整的数据记录。这种索引叫做聚集索引。因为InnoDB的数据文件本身要按主键聚集,所以InnoDB要求表必须有主键(MyISAM可以没有),如果没有显式指定,则MySQL系统会自动选择一个可以唯一标识数据记录的列作为主键,如果不存在这种列,则MySQL自动为InnoDB表生成一个隐含字段作为主键,这个字段长度为6个字节,类型为长整形。

     

    2). InnoDB的辅助索引

           InnoDB的所有辅助索引都引用主键作为data域。例如,下图为定义在Col3上的一个辅助索引:

     

        

           

            InnoDB 表是基于聚簇索引建立的。因此InnoDB 的索引能提供一种非常快速的主键查找性能。不过,它的辅助索引(Secondary Index, 也就是非主键索引)也会包含主键列,所以,如果主键定义的比较大,其他索引也将很大。如果想在表上定义 、很多索引,则争取尽量把主键定义得小一些。InnoDB 不会压缩索引。

          文字符的ASCII码作为比较准则。聚集索引这种实现方式使得按主键的搜索十分高效,但是辅助索引搜索需要检索两遍索引:首先检索辅助索引获得主键,然后用主键到主索引中检索获得记录。

          不同存储引擎的索引实现方式对于正确使用和优化索引都非常有帮助,例如知道了InnoDB的索引实现后,就很容易明白为什么不建议使用过长的字段作为主键,因为所有辅助索引都引用主索引,过长的主索引会令辅助索引变得过大。再例如,用非单调的字段作为主键在InnoDB中不是个好主意,因为InnoDB数据文件本身是一颗B+Tree,非单调的主键会造成在插入新记录时数据文件为了维持B+Tree的特性而频繁的分裂调整,十分低效,而使用自增字段作为主键则是一个很好的选择。

     InnoDB索引MyISAM索引的区别:

    一是主索引的区别,InnoDB的数据文件本身就是索引文件。而MyISAM的索引和数据是分开的。

    二是辅助索引的区别:InnoDB的辅助索引data域存储相应记录主键的值而不是地址。而MyISAM的辅助索引和主索引没有多大区别

    展开全文
  • B树、B+树、B*树谈到R 树

    万次阅读 多人点赞 2011-06-07 17:52:00
    从B 树、B+ 树、B* 树谈到R 树 ...其中B树、B+树及B*树部分由weedge完成,R 树部分由Frankie完成,全文最终由July统稿修订完成。 出处:http://blog.csdn.net/v_JULY_v 。   第一节、B树、B+树、B*...

    从B 树、B+ 树、B* 树谈到R 树

     

    作者:July、weedge、Frankie。编程艺术室出品。

    说明:本文从B树开始谈起,然后论述B+树、B*树,最后谈到R 树。其中B树、B+树及B*树部分由weedge完成,R 树部分由Frankie完成,全文最终由July统稿修订完成。

    出处:http://blog.csdn.net/v_JULY_v 

     

    第一节、B树、B+树、B*树

    1.前言:

    动态查找树主要有:二叉查找树(Binary Search Tree),平衡二叉查找树(Balanced Binary Search Tree),红黑树(Red-Black Tree ),B-tree/B+-tree/ B*-tree (B~Tree)。前三者是典型的二叉查找树结构,其查找的时间复杂度O(log2N)与树的深度相关,那么降低树的深度自然会提高查找效率。

    但是咱们有面对这样一个实际问题:就是大规模数据存储中,实现索引查询这样一个实际背景下,树节点存储的元素数量是有限的(如果元素数量非常多的话,查找就退化成节点内部的线性查找了),这样导致二叉查找树结构由于树的深度过大而造成磁盘I/O读写过于频繁,进而导致查询效率低下(为什么会出现这种情况,待会在外部存储器-磁盘中有所解释),那么如何减少树的深度(当然是不能减少查询的数据量),一个基本的想法就是:采用多叉树结构(由于树节点元素数量是有限的,自然该节点的子树数量也就是有限的)。

    也就是说,因为磁盘的操作费时费资源,如果过于频繁的多次查找势必效率低下。那么如何提高效率,即如何避免磁盘过于频繁的多次查找呢?根据磁盘查找存取的次数往往由树的高度所决定,所以,只要我们通过某种较好的树结构减少树的结构尽量减少树的高度,那么是不是便能有效减少磁盘查找存取的次数呢?那这种有效的树结构是一种怎样的树呢?

    这样我们就提出了一个新的查找树结构——多路查找树。根据平衡二叉树的启发,自然就想到平衡多路查找树结构,也就是这篇文章所要阐述的第一个主题B~tree,即B树结构(后面,我们将看到,B树的各种操作能使B树保持较低的高度,从而达到有效避免磁盘过于频繁的查找存取操作,从而有效提高查找效率)。

    B-tree(B-tree树即B树,B即Balanced,平衡的意思)这棵神奇的树是在Rudolf BayerEdward M. McCreight(1970)写的一篇论文《Organization and Maintenance of Large Ordered Indices》中首次提出的(wikipedia中:http://en.wikipedia.org/wiki/B-tree,阐述了B-tree名字来源以及相关的开源地址)。

    在开始介绍B~tree之前,先了解下相关的硬件知识,才能很好的了解为什么需要B~tree这种外存数据结构。 

     

    2.外存储器磁盘

    计算机存储设备一般分为两种内存储器(main memory)和外存储器(external memory) 内存存取速度快,但容量小,价格昂贵,而且不能长期保存数据(在不通电情况下数据会消失)

    外存储器—磁盘是一种直接存取的存储设备(DASD)。它是以存取时间变化不大为特征的。可以直接存取任何字符组,且容量大、速度较其它外存设备更快。

    2.1磁盘的构造

    磁盘是一个扁平的圆盘(与电唱机的唱片类似)。盘面上有许多称为磁道的圆圈,数据就记录在这些磁道上。磁盘可以是单片的,也可以是由若干盘片组成的盘组,每一盘片上有两个面。如下图11.3中所示的6片盘组为例,除去最顶端和最底端的外侧面不存储数据之外,一共有10个面可以用来保存信息。

                               

     

    当磁盘驱动器执行读/写功能时。盘片装在一个主轴上,并绕主轴高速旋转,当磁道在读/写头(又叫磁头) 下通过时,就可以进行数据的读 / 写了。

    一般磁盘分为固定头盘(磁头固定)和活动头盘。固定头盘的每一个磁道上都有独立的磁头,它是固定不动的,专门负责这一磁道上数据的读/写。

    活动头盘 (如上图)的磁头是可移动的。每一个盘面上只有一个磁头(磁头是双向的,因此正反盘面都能读写)。它可以从该面的一个磁道移动到另一个磁道。所有磁头都装在同一个动臂上,因此不同盘面上的所有磁头都是同时移动的(行动整齐划一)。当盘片绕主轴旋转的时候,磁头与旋转的盘片形成一个圆柱体。各个盘面上半径相同的磁道组成了一个圆柱面,我们称为柱面 。因此,柱面的个数也就是盘面上的磁道数。 

    2.2磁盘的读/写原理和效率

    磁盘上数据必须用一个三维地址唯一标示:柱面号、盘面号、块号(磁道上的盘块)

    /写磁盘上某一指定数据需要下面3个步骤:

    (1)  首先移动臂根据柱面号使磁头移动到所需要的柱面上,这一过程被称为定位或查找

    (2)  如上图11.3中所示的6盘组示意图中,所有磁头都定位到了10个盘面的10条磁道上(磁头都是双向的)。这时根据盘面号来确定指定盘面上的磁道。

    (3) 盘面确定以后,盘片开始旋转,将指定块号的磁道段移动至磁头下。

    经过上面三个步骤,指定数据的存储位置就被找到。这时就可以开始读/写操作了。

    访问某一具体信息,由3部分时间组成:

    查找时间(seek time) Ts: 完成上述步骤(1)所需要的时间。这部分时间代价最高,最大可达到0.1s左右。

    等待时间(latency time) Tl: 完成上述步骤(3)所需要的时间。由于盘片绕主轴旋转速度很快,一般为7200/(电脑硬盘的性能指标之一, 家用的普通硬盘的转速一般有5400rpm(笔记本)7200rpm几种)因此一般旋转一圈大约0.0083s

    传输时间(transmission time) Tt: 数据通过系统总线传送到内存的时间,一般传输一个字节(byte)大概0.02us=2*10^(-8)s

    磁盘读取数据是以盘块(block)为基本单位的。位于同一盘块中的所有数据都能被一次性全部读取出来。而磁盘IO代价主要花费在查找时间Ts上。因此我们应该尽量将相关信息存放在同一盘块,同一磁道中。或者至少放在同一柱面或相邻柱面上,以求在读/写信息时尽量减少磁头来回移动的次数,避免过多的查找时间Ts

    所以,在大规模数据存储方面,大量数据存储在外存磁盘中,而在外存磁盘中读取/写入块(block)中某数据时,首先需要定位到磁盘中的某块,如何有效地查找磁盘中的数据,需要一种合理高效的外存数据结构,就是下面所要重点阐述的B-tree结构,以及相关的变种结构:B+-tree结构和B*-tree结构。

     

     

    3.B树 

         3.1什么是B树

    具体讲解之前,有一点,再次强调下:有的文章里出现的B-树,即为B树。因为B树的原英文名称为B-tree,而国内很多人喜欢把B-tree译作B-树,其实,这是个非常不好的直译,很容易让人产生误解。如人们可能会以为B-树是一种树,而B树又是一种一种树。而事实上是,B-tree就是指的B树。特此说明。

    我们知道,B 树是为了磁盘或其它存储设备而设计的一种多叉(下面你会看到,相对于二叉,B树每个内结点有多个分支,即多叉)平衡查找树。与本blog之前介绍的红黑树很相似,但在降低磁盘I/0操作方面要更好一些。许多数据库系统都一般使用B树或者B树的各种变形结构,如下文即将要介绍的B+树,B*树来存储信息。

     B树与红黑树最大的不同在于,B树的结点可以有许多子女,从几个到几千个。那为什么又说B树与红黑树很相似呢?因为与红黑树一样,一棵含n个结点的B树的高度也为O(lgn),但可能比一棵红黑树的高度小许多,应为它的分支因子比较大。所以,B树可以在O(logn)时间内,实现各种如插入(insert),删除(delete)等动态集合操作。

    如下图所示,即是一棵B树,一棵关键字为英语中辅音字母的B树,现在要从树种查找字母R(包含n[x]个关键字的内结点x,x有n[x]+1]个子女(也就是说,一个内结点x若含有n[x]个关键字,那么x将含有n[x]+1个子女)。所有的叶结点都处于相同的深度,带阴影的结点为查找字母R时要检查的结点):

     

    相信,从上图你能轻易的看到,一个内结点x若含有n[x]个关键字,那么x将含有n[x]+1个子女。如含有2个关键字D H的内结点有3个子女,而含有3个关键字Q T X的内结点有4个子女。

        B树的定义,从下文中,你将看到,或者是用阶,或者是用度,如下段文字所述:
        Unfortunately, the literature on B-trees is not uniform in its use of terms relating to B-Trees. (Folk & Zoellick 1992, p. 362) Bayer & McCreight (1972), Comer (1979), and others define the order of B-tree as the minimum number of keys in a non-root node. Folk & Zoellick (1992) points out that terminology is ambiguous because the maximum number of keys is not clear. An order 3 B-tree might hold a maximum of 6 keys or a maximum of 7 keys. (Knuth 1998,TAOCP p. 483) avoids the problem by defining the order to be maximum number of children (which is one more than the maximum number of keys).

        from: http://en.wikipedia.org/wiki/Btree#Technical_description

        用阶定义的B树

        B 树又叫平衡多路查找树。一棵m阶的B 树 (注:切勿简单的认为一棵m阶的B树是m叉树,虽然存在四叉树八叉树KD,及vp/R树/R*树/R+树/X树/M树/线段树/希尔伯特R树/优先R树等空间划分树,但与B树完全不等同)的特性如下

    1. 树中每个结点最多含有m个孩子(m>=2);

    2. 除根结点和叶子结点外,其它每个结点至少有[ceil(m / 2)]个孩子(其中ceil(x)是一个取上限的函数);

    3. 若根结点不是叶子结点,则至少有2个孩子(特殊情况:没有孩子的根结点,即根结点为叶子结点,整棵树只有一个根节点);

    4. 所有叶子结点都出现在同一层,叶子结点不包含任何关键字信息(可以看做是外部接点或查询失败的接点,实际上这些结点不存在,指向这些结点的指针都为null);(读者反馈@冷岳这里有错,叶子节点只是没有孩子和指向孩子的指针,这些节点也存在,也有元素。@研究者July:其实,关键是把什么当做叶子结点,因为如红黑树中,每一个NULL指针即当做叶子结点,只是没画出来而已)。

    5. 每个非终端结点中包含有n个关键字信息: (n,P0,K1,P1,K2,P2,......,Kn,Pn)。其中:
             a)   Ki (i=1...n)为关键字,且关键字按顺序升序排序K(i-1)< Ki。
             b)   Pi为指向子树根的接点,且指针P(i-1)指向子树种所有结点的关键字均小于Ki,但都大于K(i-1)。 
             c)   关键字的个数n必须满足: [ceil(m / 2)-1]<= n <= m-1。
      如下图所示:

        用度定义的B树

          针对上面的5点,再阐述下:B树中每一个结点能包含的关键字(如之前上面的D HQ T X)数有一个上界和下界。这个下界可以用一个称作B树的最小度数(算法导论中文版上译作度数,最小度数即内节点中节点最小孩子数目)m(m>=2)表示。

    • 每个非根的内结点至多有m个子女,每个非根的结点必须至少含有m-1个关键字,如果树是非空的,则根结点至少包含一个关键字;

    • 每个结点可包含至多2m-1个关键字。所以一个内结点至多可有2m个子女。如果一个结点恰好有2m-1个关键字,我们就说这个结点是满的(而稍后介绍的B*树作为B树的一种常用变形,B*树中要求每个内结点至少为2/3满,而不是像这里的B树所要求的至少半满);

    • 当关键字数m=2(t=2的意思是,mmin=2,m可以>=2)时的B树是最简单的有很多人会因此误认为B树就是二叉查找树,但二叉查找树就是二叉查找树,B树就是B树,B树是一棵含有m(m>=2)个关键字的平衡多路查找树,此时,每个内结点可能因此而含有2个、3个或4个子女,亦即一棵2-3-4树,然而在实际中,通常采用大得多的t值。

        B树中的每个结点根据实际情况可以包含大量的关键字信息和分支(当然是不能超过磁盘块的大小,根据磁盘驱动(disk drives)的不同,一般块的大小在1k~4k左右);这样树的深度降低了,这就意味着查找一个元素只要很少结点从外存磁盘中读入内存,很快访问到要查找的数据。如果你看完上面关于B树定义的介绍,思维感觉不够清晰,请继续参阅下文第6小节、B树的插入、删除操作 部分

        3.2B树的类型和节点定义

        B树的类型和节点定义如下图所示:

     

     

        3.3文件查找的具体过程(涉及磁盘IO操作)

    为了简单,这里用少量数据构造一棵3叉树的形式,实际应用中的B树结点中关键字很多的。上面的图中比如根结点,其中17表示一个磁盘文件的文件名;小红方块表示这个17文件内容在硬盘中的存储位置;p1表示指向17左子树的指针。

    其结构可以简单定义为:

    typedef struct {

        /*文件数*/

        int  file_num;

        /*文件名(key)*/

        char * file_name[max_file_num];

        /*指向子节点的指针*/

         BTNode * BTptr[max_file_num+1];

         /*文件在硬盘中的存储位置*/

         FILE_HARD_ADDR offset[max_file_num];

    }BTNode;

    假如每个盘块可以正好存放一个B树的结点(正好存放2个文件名)。那么一个BTNODE结点就代表一个盘块,而子树指针就是存放另外一个盘块的地址。

    下面,咱们来模拟下查找文件29的过程:

    1. 根据根结点指针找到文件目录的根磁盘块1,将其中的信息导入内存。【磁盘IO操作 1次】    

    2. 此时内存中有两个文件名17、35和三个存储其他磁盘页面地址的数据。根据算法我们发现:17<29<35,因此我们找到指针p2

    3. 根据p2指针,我们定位到磁盘块3,并将其中的信息导入内存。【磁盘IO操作 2次】    

    4. 此时内存中有两个文件名26,30和三个存储其他磁盘页面地址的数据。根据算法我们发现:26<29<30,因此我们找到指针p2

    5. 根据p2指针,我们定位到磁盘块8,并将其中的信息导入内存。【磁盘IO操作 3次】    

    6. 此时内存中有两个文件名28,29。根据算法我们查找到文件名29,并定位了该文件内存的磁盘地址。

    分析上面的过程,发现需要3次磁盘IO操作和3次内存查找操作。关于内存中的文件名查找,由于是一个有序表结构,可以利用折半查找提高效率。至于IO操作是影响整个B树查找效率的决定因素。

    当然,如果我们使用平衡二叉树的磁盘存储结构来进行查找,磁盘4次,最多5次,而且文件越多,B树比平衡二叉树所用的磁盘IO操作次数将越少,效率也越高

     

    3.4B树的高度

        根据上面的例子我们可以看出,对于辅存做IO读的次数取决于B树的高度。而B树的高度由什么决定的呢?

        若B树某一非叶子节点包含N个关键字,则此非叶子节点含有N+1个孩子结点,而所有的叶子结点都在第I层,我们可以得出:

    1. 因为根至少有两个孩子,因此第2层至少有两个结点。
    2. 除根和叶子外,其它结点至少有┌m/2┐个孩子,
    3. 因此在第3层至少有2*┌m/2┐个结点,
    4. 在第4层至少有2*(┌m/2┐^2)个结点,
    5. 在第 I 层至少有2*(┌m/2┐^(l-2) )个结点,于是有: N+1 ≥ 2*┌m/2┐I-2;
    6. 考虑第L层的结点个数为N+1,那么2*(┌m/2┐^(l-2))≤N+1,也就是L层的最少结点数刚好达到N+1个,即: I≤ log┌m/2┐((N+1)/2 )+2;

      所以

    • 当B树包含N个关键字时,B树的最大高度为l-1(因为计算B树高度时,叶结点所在层不计算在内),即:l - 1 = log┌m/2┐((N+1)/2 )+1

      这个B树的高度公式从侧面显示了B树的查找效率是相当高的

    曾在一次面试中被问到,一棵含有N个总关键字数的m阶的B树的最大高度是多少?答曰:log_ceil(m/2)(N+1)/2 + 1 (上面中关于m阶B树的第1点特性已经提到:树中每个结点含有最多含有m个孩子,即m满足:ceil(m/2)<=m<=m。而树中每个结点含孩子数越少,树的高度则越大,故如此)。在2012微软4月份的笔试中也问到了此问题。

    此外,还有读者反馈,说上面的B树的高度计算公式与算法导论一书上的不同,而后我特意翻看了算法导论第18章关于B树的高度一节的内容,如下图所示:

    在上图中书上所举的例子中,也许,根据我们大多数人的理解,它的高度应该是4,而书上却说的是“一棵高度为3的B树”。我想,此时,你也就明白了,算法导论一书上的高度的定义是从“0”开始计数的,而我们中国人的习惯是树的高度是从“1”开始计数的。特此说明。July、二零一二年九月二十七日。

     

    4.B+-tree

    B+-tree:是应文件系统所需而产生的一种B-tree的变形树。

    一棵m阶的B+树和m阶的B树的异同点在于:

          1.n棵子树的结点中含有n-1 个关键字; (此处颇有争议,B+树到底是与B 树n棵子树有n-1个关键字 保持一致,还是不一致:B树n棵子树的结点中含有n个关键字,待后续查证。暂先提供两个参考链接:①wikipedia http://en.wikipedia.org/wiki/B%2B_tree#Overview;②http://hedengcheng.com/?p=525。而下面B+树的图尚未最终确定是否有问题,请读者注意)

          2.所有的叶子结点中包含了全部关键字的信息,及指向含有这些关键字记录的指针,且叶子结点本身依关键字的大小自小而大的顺序链接。 (而B 树的叶子节点并没有包括全部需要查找的信息)

          3.所有的非终端结点可以看成是索引部分,结点中仅含有其子树根结点中最大(或最小)关键字。 (而B 树的非终节点也包含需要查找的有效信息)

     

    a)     为什么说B+-tree比B 树更适合实际应用中操作系统的文件索引和数据库索引?

    1) B+-tree的磁盘读写代价更低

    B+-tree的内部结点并没有指向关键字具体信息的指针。因此其内部结点相对B 树更小。如果把所有同一内部结点的关键字存放在同一盘块中,那么盘块所能容纳的关键字数量也越多。一次性读入内存中的需要查找的关键字也就越多。相对来说IO读写次数也就降低了。

        举个例子,假设磁盘中的一个盘块容纳16bytes,而一个关键字2bytes,一个关键字具体信息指针2bytes。一棵9B-tree(一个结点最多8个关键字)的内部结点需要2个盘快。而B+ 树内部结点只需要1个盘快。当需要把内部结点读入内存中的时候,B 树就比B+ 树多一次盘块查找时间(在磁盘中就是盘片旋转的时间)

    2) B+-tree的查询效率更加稳定

    由于非终结点并不是最终指向文件内容的结点,而只是叶子结点中关键字的索引。所以任何关键字的查找必须走一条从根结点到叶子结点的路。所有关键字查询的路径长度相同,导致每一个数据的查询效率相当。

    读者点评
    本文评论下第149楼,fanyy1991针对上文所说的两点,道:个人觉得这两个原因都不是主要原因。数据库索引采用B+树的主要原因是 B树在提高了磁盘IO性能的同时并没有解决元素遍历的效率低下的问题。正是为了解决这个问题,B+树应运而生。B+树只要遍历叶子节点就可以实现整棵树的遍历。而且在数据库中基于范围的查询是非常频繁的,而B树不支持这样的操作(或者说效率太低)。

    b)    B+-tree的应用: VSAM(虚拟存储存取法)文件(来源论文 the ubiquitous Btree 作者:D COMER - 1979 )

     

     

    5.B*-tree

    B*-treeB+-tree的变体,在B+树的基础上(所有的叶子结点中包含了全部关键字的信息,及指向含有这些关键字记录的指针),B*树中非根和非叶子结点再增加指向兄弟的指针;B*树定义了非叶子结点关键字个数至少为(2/3)*M,即块的最低使用率为2/3(代替B+树的1/2)。给出了一个简单实例,如下图所示:

     

    B+树的分裂:当一个结点满时,分配一个新的结点,并将原结点中1/2的数据复制到新结点,最后在父结点中增加新结点的指针;B+树的分裂只影响原结点和父结点,而不会影响兄弟结点,所以它不需要指向兄弟的指针。

    B*树的分裂:当一个结点满时,如果它的下一个兄弟结点未满,那么将一部分数据移到兄弟结点中,再在原结点插入关键字,最后修改父结点中兄弟结点的关键字(因为兄弟结点的关键字范围改变了);如果兄弟也满了,则在原结点与兄弟结点之间增加新结点,并各复制1/3的数据到新结点,最后在父结点增加新结点的指针。

    所以,B*树分配新结点的概率比B+树要低,空间使用率更高。

     

    6、B树的插入、删除操作

    上面第3小节简单介绍了利用B树这种结构如何访问外存磁盘中的数据的情况,下面咱们通过另外一个实例来对这棵B树的插入(insert),删除(delete)基本操作进行详细的介绍。

    但在此之前,咱们还得简单回顾下一棵m阶的B 树的特性,如下:

    1. 树中每个结点含有最多含有m个孩子,即m满足:ceil(m/2)<=m<=m。

    2. 除根结点和叶子结点外,其它每个结点至少有[ceil(m / 2)]个孩子(其中ceil(x)是一个取上限的函数);

    3. 若根结点不是叶子结点,则至少有2个孩子(特殊情况:没有孩子的根结点,即根结点为叶子结点,整棵树只有一个根节点);

    4. 所有叶子结点都出现在同一层,叶子结点不包含任何关键字信息(可以看做是外部接点或查询失败的接点,实际上这些结点不存在,指向这些结点的指针都为null);

    5. 每个非终端结点中包含有n个关键字信息: (n,P0,K1,P1,K2,P2,......,Kn,Pn)。其中:
             a)   Ki (i=1...n)为关键字,且关键字按顺序升序排序K(i-1)< Ki。
             b)   Pi为指向子树根的接点,且指针P(i-1)指向子树种所有结点的关键字均小于Ki,但都大于K(i-1)。 
             c)   除根结点之外的结点的关键字的个数n必须满足: [ceil(m / 2)-1]<= n <= m-1(叶子结点也必须满足此条关于关键字数的性质,根结点除外)。

    ok,下面咱们以一棵5阶(即树中任一结点至多含有4个关键字,5棵子树)B树实例进行讲解(如下图所示):

    备注:关键字数(2-4个)针对--非根结点(包括叶子结点在内),孩子数(3-5个)--针对根结点和叶子结点之外的内结点。当然,根结点是必须至少有2个孩子的,不然就成直线型搜索树了。下图中,读者可以看到关键字数2-4个,内结点孩子数3-5个:

    关键字为大写字母,顺序为字母升序。

    结点定义如下:

    typedef struct{

       int Count;         // 当前节点中关键元素数目

       ItemType Key[4];   // 存储关键字元素的数组

       long Branch[5];    // 伪指针数组,(记录数目)方便判断合并和分裂的情况

    } NodeType;

     

    6.1、插入(insert)操作

    插入一个元素时,首先在B树中是否存在,如果不存在,即在叶子结点处结束,然后在叶子结点中插入该新的元素,注意:如果叶子结点空间足够,这里需要向右移动该叶子结点中大于新插入关键字的元素,如果空间满了以致没有足够的空间去添加新的元素,则将该结点进行“分裂”,将一半数量的关键字元素分裂到新的其相邻右结点中,中间关键字元素上移到父结点中(当然,如果父结点空间满了,也同样需要“分裂”操作),而且当结点中关键元素向右移动了,相关的指针也需要向右移。如果在根结点插入新元素,空间满了,则进行分裂操作,这样原来的根结点中的中间关键字元素向上移动到新的根结点中,因此导致树的高度增加一层。如下图所示:

    1、OK,下面咱们通过一个实例来逐步讲解下。插入以下字符字母到一棵空的B 树中(非根结点关键字数小了(小于2个)就合并,大了(超过4个)就分裂):C N G A H E K Q M F W L T Z D P R X Y S,首先,结点空间足够,4个字母插入相同的结点中,如下图:

     

    2、当咱们试着插入H时,结点发现空间不够,以致将其分裂成2个结点,移动中间元素G上移到新的根结点中,在实现过程中,咱们把A和C留在当前结点中,而H和N放置新的其右邻居结点中。如下图:

     

    3、当咱们插入E,K,Q时,不需要任何分裂操作

     

    4、插入M需要一次分裂,注意M恰好是中间关键字元素,以致向上移到父节点中

     

    5、插入F,W,L,T不需要任何分裂操作

     

    6、插入Z时,最右的叶子结点空间满了,需要进行分裂操作,中间元素T上移到父节点中,注意通过上移中间元素,树最终还是保持平衡,分裂结果的结点存在2个关键字元素。

     

    7、插入D时,导致最左边的叶子结点被分裂,D恰好也是中间元素,上移到父节点中,然后字母P,R,X,Y陆续插入不需要任何分裂操作(别忘了,树中至多5个孩子)。

     

    8、最后,当插入S时,含有N,P,Q,R的结点需要分裂,把中间元素Q上移到父节点中,但是情况来了,父节点中空间已经满了,所以也要进行分裂,将父节点中的中间元素M上移到新形成的根结点中,注意以前在父节点中的第三个指针在修改后包括D和G节点中。这样具体插入操作的完成,下面介绍删除操作,删除操作相对于插入操作要考虑的情况多点。

     

    6.2、删除(delete)操作

    首先查找B树中需删除的元素,如果该元素在B树中存在,则将该元素在其结点中进行删除,如果删除该元素后,首先判断该元素是否有左右孩子结点,如果有,则上移孩子结点中的某相近元素(“左孩子最右边的节点”或“右孩子最左边的节点”)到父节点中,然后移动之后情况;如果没有,直接删除后,移动之后的情况

    删除元素,移动相应元素之后,如果某结点中元素数目(即关键字数)小于ceil(m/2)-1,则需要看其某相邻兄弟结点是否丰满(结点中元素个数大于ceil(m/2)-1)(还记得第一节中关于B树的第5个特性中的c点么?: c)除根结点之外的结点(包括叶子结点)的关键字的个数n必须满足: (ceil(m / 2)-1)<= n <= m-1。m表示最多含有m个孩子,n表示关键字数。在本小节中举的一颗B树的示例中,关键字数n满足:2<=n<=4),如果丰满,则向父节点借一个元素来满足条件;如果其相邻兄弟都刚脱贫,即借了之后其结点数目小于ceil(m/2)-1,则该结点与其相邻的某一兄弟结点进行“合并”成一个结点,以此来满足条件。那咱们通过下面实例来详细了解吧。

    以上述插入操作构造的一棵5阶B树(树中最多含有m(m=5)个孩子,因此关键字数最小为ceil(m / 2)-1=2。还是这句话,关键字数小了(小于2个)就合并,大了(超过4个)就分裂)为例,依次删除H,T,R,E。

    1、首先删除元素H,当然首先查找H,H在一个叶子结点中,且该叶子结点元素数目3大于最小元素数目ceil(m/2)-1=2,则操作很简单,咱们只需要移动K至原来H的位置,移动L至K的位置(也就是结点中删除元素后面的元素向前移动)

     

    2、下一步,删除T,因为T没有在叶子结点中,而是在中间结点中找到,咱们发现他的继承者W(字母升序的下个元素),将W上移到T的位置,然后将原包含W的孩子结点中的W进行删除,这里恰好删除W后,该孩子结点中元素个数大于2,无需进行合并操作。

     

    3、下一步删除R,R在叶子结点中,但是该结点中元素数目为2,删除导致只有1个元素,已经小于最小元素数目ceil(5/2)-1=2,而由前面我们已经知道:如果其某个相邻兄弟结点中比较丰满(元素个数大于ceil(5/2)-1=2),则可以向父结点借一个元素,然后将最丰满的相邻兄弟结点中上移最后或最前一个元素到父节点中(有没有看到红黑树中左旋操作的影子?),在这个实例中,右相邻兄弟结点中比较丰满(3个元素大于2),所以先向父节点借一个元素W下移到该叶子结点中,代替原来S的位置,S前移;然后X在相邻右兄弟结点中上移到父结点中,最后在相邻右兄弟结点中删除X,后面元素前移。

     

    4、最后一步删除E, 删除后会导致很多问题,因为E所在的结点数目刚好达标,刚好满足最小元素个数(ceil(5/2)-1=2,而相邻的兄弟结点也是同样的情况,删除一个元素都不能满足条件,所以需要该节点与某相邻兄弟结点进行合并操作;首先移动父结点中的元素(该元素在两个需要合并的两个结点元素之间)下移到其子结点中,然后将这两个结点进行合并成一个结点。所以在该实例中,咱们首先将父节点中的元素D下移到已经删除E而只有F的结点中,然后将含有D和F的结点和含有A,C的相邻兄弟结点进行合并成一个结点。

     

    5、也许你认为这样删除操作已经结束了,其实不然,在看看上图,对于这种特殊情况,你立即会发现父节点只包含一个元素G,没达标(因为非根节点包括叶子结点的关键字数n必须满足于2=<n<=4,而此处的n=1),这是不能够接受的。如果这个问题结点的相邻兄弟比较丰满,则可以向父结点借一个元素。假设这时右兄弟结点(含有Q,X)有一个以上的元素(Q右边还有元素),然后咱们将M下移到元素很少的子结点中,将Q上移到M的位置,这时,Q的左子树将变成M的右子树,也就是含有N,P结点被依附在M的右指针上。所以在这个实例中,咱们没有办法去借一个元素,只能与兄弟结点进行合并成一个结点,而根结点中的唯一元素M下移到子结点,这样,树的高度减少一层。

     

    为了进一步详细讨论删除的情况,再举另外一个实例

    这里是一棵不同的5序B树,那咱们试着删除C

     

    于是将删除元素C的右子结点中的D元素上移到C的位置,但是出现上移元素后,只有一个元素的结点的情况。

    又因为含有E的结点,其相邻兄弟结点才刚脱贫(最少元素个数为2),不可能向父节点借元素,所以只能进行合并操作,于是这里将含有A,B的左兄弟结点和含有E的结点进行合并成一个结点。

     

    这样又出现只含有一个元素F结点的情况,这时,其相邻的兄弟结点是丰满的(元素个数为3>最小元素个数2,这样就可以想父结点借元素了,把父结点中的J下移到该结点中,相应的如果结点中J后有元素则前移,然后相邻兄弟结点中的第一个元素(或者最后一个元素)上移到父节点中,后面的元素(或者前面的元素)前移(或者后移);注意含有K,L的结点以前依附在M的左边,现在变为依附在J的右边。这样每个结点都满足B树结构性质。

     

    从以上操作可看出:除根结点之外的结点(包括叶子结点)的关键字的个数n满足:(ceil(m / 2)-1)<= n <= m-1,即2<=n<=4。这也佐证了咱们之前的观点。删除操作完。

     

     

    7.总结

    通过以上介绍,大致将B树,B+树,B*树总结如下:

    B树:有序数组+平衡多叉树;

    B+树:有序数组链表+平衡多叉树;

    B*树:一棵丰满的B+树。

        在大规模数据存储的文件系统中,B~tree系列数据结构,起着很重要的作用,对于存储不同的数据,节点相关的信息也是有所不同,这里根据自己的理解,画的一个查找以职工号为关键字,职工号为38的记录的简单示意图。(这里假设每个物理块容纳3个索引,磁盘的I/O操作的基本单位是块(block),磁盘访问很费时,采用B+树有效的减少了访问磁盘的次数。)

    对于像MySQLDB2Oracle等数据库中的索引结构得有较深入的了解才行,建议去找一些B 树相关的开源代码研究。

    走进搜索引擎的作者梁斌老师针对B树、B+树给出了他的意见(为了真实性,特引用其原话,未作任何改动): “B+树还有一个最大的好处,方便扫库,B树必须用中序遍历的方法按序扫库,而B+树直接从叶子结点挨个扫一遍就完了,B+树支持range-query非常方便,而B树不支持。这是数据库选用B+树的最主要原因。

        比如要查 5-10之间的,B+树一把到5这个标记,再一把到10,然后串起来就行了,B树就非常麻烦。B树的好处,就是成功查询特别有利,因为树的高度总体要比B+树矮。不成功的情况下,B树也比B+树稍稍占一点点便宜。

        B树比如你的例子中查,17的话,一把就得到结果了,
    有很多基于频率的搜索是选用B树,越频繁query的结点越往根上走,前提是需要对query做统计,而且要对key做一些变化。

        另外B树也好B+树也好,根或者上面几层因为被反复query,所以这几块基本都在内存中,不会出现读磁盘IO,一般已启动的时候,就会主动换入内存。”非常感谢。

        Bucket Li:"mysql 底层存储是用B+树实现的,知道为什么么。内存中B+树是没有优势的,但是一到磁盘,B+树的威力就出来了"。

     

     

     

    第二节、R树:处理空间存储问题

    相信经过上面第一节的介绍,你已经对B树或者B+树有所了解。这种树可以非常好的处理一维空间存储的问题。B树是一棵平衡树,它是把一维直线分为若干段线段,当我们查找满足某个要求的点的时候,只要去查找它所属的线段即可。依我看来,这种思想其实就是先找一个大的空间,再逐步缩小所要查找的空间,最终在一个自己设定的最小不可分空间内找出满足要求的解。一个典型的B树查找如下:

    要查找某一满足条件的点,先去找到满足条件的线段,然后遍历所在线段上的点,即可找到答案。

    B树是一种相对来说比较复杂的数据结构,尤其是在它的删除与插入操作过程中,因为它涉及到了叶子结点的分解与合并。由于本文第一节已经详细介绍了B树和B+树,下面直接开始介绍我们的第二个主角:R树。

     

    简介

    1984年,加州大学伯克利分校的Guttman发表了一篇题为“R-trees: a dynamic index structure for spatial searching”的论文,向世人介绍了R树这种处理高维空间存储问题的数据结构。本文便是基于这篇论文写作完成的,因此如果大家对R树非常有兴趣,我想最好还是参考一下原著:)。为表示对这位牛人的尊重,给个引用先:

    Guttman, A.; “R-trees: a dynamic index structure for spatial searching,” ACM, 1984, 14

    R树在数据库等领域做出的功绩是非常显著的。它很好的解决了在高维空间搜索等问题。举个R树在现实领域中能够解决的例子:查找20英里以内所有的餐厅。如果没有R树你会怎么解决?一般情况下我们会把餐厅的坐标(x,y)分为两个字段存放在数据库中,一个字段记录经度,另一个字段记录纬度。这样的话我们就需要遍历所有的餐厅获取其位置信息,然后计算是否满足要求。如果一个地区有100家餐厅的话,我们就要进行100次位置计算操作了,如果应用到谷歌地图这种超大数据库中,这种方法便必定不可行了。

    R树就很好的解决了这种高维空间搜索问题。它把B树的思想很好的扩展到了多维空间,采用了B树分割空间的思想,并在添加、删除操作时采用合并、分解结点的方法,保证树的平衡性。因此,R树就是一棵用来存储高维数据的平衡树。

    OK,接下来,本文将详细介绍R树的数据结构以及R树的操作。至于R树的扩展与R树的性能问题,可以查阅相关论文。

     

    R树的数据结构

    如上所述,R树是B树在高维空间的扩展,是一棵平衡树。每个R树的叶子结点包含了多个指向不同数据的指针,这些数据可以是存放在硬盘中的,也可以是存在内存中。根据R树的这种数据结构,当我们需要进行一个高维空间查询时,我们只需要遍历少数几个叶子结点所包含的指针,查看这些指针指向的数据是否满足要求即可。这种方式使我们不必遍历所有数据即可获得答案,效率显著提高。下图1是R树的一个简单实例:

    我们在上面说过,R树运用了空间分割的理念,这种理念是如何实现的呢?R树采用了一种称为MBR(Minimal Bounding Rectangle)的方法,在此我把它译作“最小边界矩形”。从叶子结点开始用矩形(rectangle)将空间框起来,结点越往上,框住的空间就越大,以此对空间进行分割。有点不懂?没关系,继续往下看。在这里我还想提一下,R树中的R应该代表的是Rectangle(此处参考wikipedia上关于R树的介绍),而不是大多数国内教材中所说的Region(很多书把R树称为区域树,这是有误的)。我们就拿二维空间来举例。下图是Guttman论文中的一幅图:

    我来详细解释一下这张图。先来看图(b)

     

    1. 首先我们假设所有数据都是二维空间下的点,图中仅仅标志了R8区域中的数据,也就是那个shape of data object。别把那一块不规则图形看成一个数据,我们把它看作是多个数据围成的一个区域。为了实现R树结构,我们用一个最小边界矩形恰好框住这个不规则区域,这样,我们就构造出了一个区域:R8。R8的特点很明显,就是正正好好框住所有在此区域中的数据。其他实线包围住的区域,如R9,R10,R12等都是同样的道理。这样一来,我们一共得到了12个最最基本的最小矩形。这些矩形都将被存储在子结点中。
    2. 下一步操作就是进行高一层次的处理。我们发现R8,R9,R10三个矩形距离最为靠近,因此就可以用一个更大的矩形R3恰好框住这3个矩形。
    3. 同样道理,R15,R16被R6恰好框住,R11,R12被R4恰好框住,等等。所有最基本的最小边界矩形被框入更大的矩形中之后,再次迭代,用更大的框去框住这些矩形。

     

    我想大家都应该理解这个数据结构的特征了。用地图的例子来解释,就是所有的数据都是餐厅所对应的地点,先把相邻的餐厅划分到同一块区域,划分好所有餐厅之后,再把邻近的区域划分到更大的区域,划分完毕后再次进行更高层次的划分,直到划分到只剩下两个最大的区域为止。要查找的时候就方便了

    下面就可以把这些大大小小的矩形存入我们的R树中去了。根结点存放的是两个最大的矩形,这两个最大的矩形框住了所有的剩余的矩形,当然也就框住了所有的数据。下一层的结点存放了次大的矩形,这些矩形缩小了范围。每个叶子结点都是存放的最小的矩形,这些矩形中可能包含有n个数据。

    在这里,读者先不要去纠结于如何划分数据到最小区域矩形,也不要纠结怎样用更大的矩形框住小矩形,这些都是下一节我们要讨论的。

    讲完了基本的数据结构,我们来讲个实例,如何查询特定的数据。又以餐厅为例,假设我要查询广州市天河区天河城附近一公里的所有餐厅地址怎么办?

     

    1. 打开地图(也就是整个R树),先选择国内还是国外(也就是根结点)。
    2. 然后选择华南地区(对应第一层结点),选择广州市(对应第二层结点),
    3. 再选择天河区(对应第三层结点),
    4. 最后选择天河城所在的那个区域(对应叶子结点,存放有最小矩形),遍历所有在此区域内的结点,看是否满足我们的要求即可。

     

    怎么样,其实R树的查找规则跟查地图很像吧?对应下图:

     

    一棵R树满足如下的性质:

    1.     除非它是根结点之外,所有叶子结点包含有m至M个记录索引(条目)。作为根结点的叶子结点所具有的记录个数可以少于m。通常,m=M/2。

    2.     对于所有在叶子中存储的记录(条目),I是最小的可以在空间中完全覆盖这些记录所代表的点的矩形(注意:此处所说的“矩形”是可以扩展到高维空间的)。

    3.     每一个非叶子结点拥有m至M个孩子结点,除非它是根结点。

    4.     对于在非叶子结点上的每一个条目,i是最小的可以在空间上完全覆盖这些条目所代表的店的矩形(同性质2)。

    5.     所有叶子结点都位于同一层,因此R树为平衡树。

    叶子结点的结构

    先来探究一下叶子结点的结构。叶子结点所保存的数据形式为:(I, tuple-identifier)。

          其中,tuple-identifier表示的是一个存放于数据库中的tuple,也就是一条记录,它是n维的。I是一个n维空间的矩形,并可以恰好框住这个叶子结点中所有记录代表的n维空间中的点。I=(I0,I1,…,In-1)。其结构如下图所示:

    下图描述的就是在二维空间中的叶子结点所要存储的信息。

    在这张图中,I所代表的就是图中的矩形,其范围是a<=I0<=b,c<=I1<=d。有两个tuple-identifier,在图中即表示为那两个点。这种形式完全可以推广到高维空间。大家简单想想三维空间中的样子就可以了。这样,叶子结点的结构就介绍完了。

     

    非叶子结点

          非叶子结点的结构其实与叶子结点非常类似。想象一下B树就知道了,B树的叶子结点存放的是真实存在的数据,而非叶子结点存放的是这些数据的“边界”,或者说也算是一种索引(有疑问的读者可以回顾一下上述第一节中讲解B树的部分

          同样道理,R树的非叶子结点存放的数据结构为:(I, child-pointer)。

          其中,child-pointer是指向孩子结点的指针,I是覆盖所有孩子结点对应矩形的矩形。这边有点拗口,但我想不是很难懂?给张图:

    D,E,F,G为孩子结点所对应的矩形。A为能够覆盖这些矩形的更大的矩形。这个A就是这个非叶子结点所对应的矩形。这时候你应该悟到了吧?无论是叶子结点还是非叶子结点,它们都对应着一个矩形。树形结构上层的结点所对应的矩形能够完全覆盖它的孩子结点所对应的矩形。根结点也唯一对应一个矩形,而这个矩形是可以覆盖所有我们拥有的数据信息在空间中代表的点的。

    我个人感觉这张图画的不那么精确,应该是矩形A要恰好覆盖D,E,F,G,而不应该再留出这么多没用的空间了。但为尊重原图的绘制者,特不作修改。

     

    R树的操作

    这一部分也许是编程者最关注的问题了。这么高效的数据结构该如何去实现呢?这便是这一节需要阐述的问题。

     

    搜索

    R树的搜索操作很简单,跟B树上的搜索十分相似。它返回的结果是所有符合查找信息的记录条目。而输入是什么?就我个人的理解,输入不仅仅是一个范围了,它更可以看成是一个空间中的矩形。也就是说,我们输入的是一个搜索矩形。

    先给出伪代码:

    Function:Search

    描述:假设T为一棵R树的根结点,查找所有搜索矩形S覆盖的记录条目。

    S1:[查找子树] 如果T是非叶子结点,如果T所对应的矩形与S有重合,那么检查所有T中存储的条目,对于所有这些条目,使用Search操作作用在每一个条目所指向的子树的根结点上(即T结点的孩子结点)。

    S2:[查找叶子结点] 如果T是叶子结点,如果T所对应的矩形与S有重合,那么直接检查S所指向的所有记录条目。返回符合条件的记录。

    我们通过下图来理解这个Search操作。

     

    阴影部分所对应的矩形为搜索矩形。它与根结点对应的最大的矩形(未画出)有重叠。这样将Search操作作用在其两个子树上。两个子树对应的矩形分别为R1与R2。搜索R1,发现与R1中的R4矩形有重叠,继续搜索R4。最终在R4所包含的R11与R12两个矩形中查找是否有符合条件的记录。搜索R2的过程同样如此。很显然,该算法进行的是一个迭代操作。

     

    插入

          R树的插入操作也同B树的插入操作类似。当新的数据记录需要被添加入叶子结点时,若叶子结点溢出,那么我们需要对叶子结点进行分裂操作。显然,叶子结点的插入操作会比搜索操作要复杂。插入操作需要一些辅助方法才能够完成。

    来看一下伪代码:

    Function:Insert

    描述:将新的记录条目E插入给定的R树中。

    I1:[为新记录找到合适插入的叶子结点] 开始ChooseLeaf方法选择叶子结点L以放置记录E。

    I2:[添加新记录至叶子结点] 如果L有足够的空间来放置新的记录条目,则向L中添加E。如果没有足够的空间,则进行SplitNode方法以获得两个结点L与LL,这两个结点包含了所有原来叶子结点L中的条目与新条目E。

    I3:[将变换向上传递] 开始对结点L进行AdjustTree操作,如果进行了分裂操作,那么同时需要对LL进行AdjustTree操作。

    I4:[对树进行增高操作] 如果结点分裂,且该分裂向上传播导致了根结点的分裂,那么需要创建一个新的根结点,并且让它的两个孩子结点分别为原来那个根结点分裂后的两个结点。

     

    Function:ChooseLeaf

    描述:选择叶子结点以放置新条目E。

    CL1:[Initialize] 设置N为根结点。

    CL2:[叶子结点的检查] 如果N为叶子结点,则直接返回N。

    CL3:[选择子树] 如果N不是叶子结点,则遍历N中的结点,找出添加E.I时扩张最小的结点,并把该结点定义为F。如果有多个这样的结点,那么选择面积最小的结点。

    CL4:[下降至叶子结点] 将N设为F,从CL2开始重复操作。

     

    Function:AdjustTree

    描述:叶子结点的改变向上传递至根结点以改变各个矩阵。在传递变换的过程中可能会产生结点的分裂。

    AT1:[初始化] 将N设为L。

    AT2:[检验是否完成] 如果N为根结点,则停止操作。

    AT3:[调整父结点条目的最小边界矩形] 设P为N的父节点,EN为指向在父节点P中指向N的条目。调整EN.I以保证所有在N中的矩形都被恰好包围。

    AT4:[向上传递结点分裂] 如果N有一个刚刚被分裂产生的结点NN,则创建一个指向NN的条目ENN。如果P有空间来存放ENN,则将ENN添加到P中。如果没有,则对P进行SplitNode操作以得到P和PP。

    AT5:[升高至下一级] 如果N等于L且发生了分裂,则把NN置为PP。从AT2开始重复操作。

     

    同样,我们用图来更加直观的理解这个插入操作。

     

        我们来通过图分析一下插入操作。现在我们需要插入R21这个矩形。开始时我们进行ChooseLeaf操作。在根结点中有两个条目,分别为R1,R2。其实R1已经完全覆盖了R21,而若向R2中添加R21,则会使R2.I增大很多。显然我们选择R1插入。然后进行下一级的操作。相比于R4,向R3中添加R21会更合适,因为R3覆盖R21所需增大的面积相对较小。这样就在R8,R9,R10所在的叶子结点中插入R21。由于叶子结点没有足够空间,则要进行分裂操作。

        插入操作如下图所示:

     

    这个插入操作其实类似于第一节中B树的插入操作,这里不再具体介绍,不过想必看过上面的伪代码大家应该也清楚了。

     

     

    删除

    R树的删除操作与B树的删除操作会有所不同,不过同B树一样,会涉及到压缩等操作。相信读者看完以下的伪代码之后会有所体会。R树的删除同样是比较复杂的,需要用到一些辅助函数来完成整个操作。

    伪代码如下:

    Function:Delete

    描述:将一条记录E从指定的R树中删除。

    D1:[找到含有记录的叶子结点] 使用FindLeaf方法找到包含有记录E的叶子结点L。如果搜索失败,则直接终止。

    D2:[删除记录] 将E从L中删除。

    D3:[传递记录] 对L使用CondenseTree操作

    D4:[缩减树] 当经过以上调整后,如果根结点只包含有一个孩子结点,则将这个唯一的孩子结点设为根结点。

     

    Function:FindLeaf

    描述:根结点为T,期望找到包含有记录E的叶子结点。

    FL1:[搜索子树] 如果T不是叶子结点,则检查每一条T中的条目F,找出与E所对应的矩形相重合的F(不必完全覆盖)。对于所有满足条件的F,对其指向的孩子结点进行FindLeaf操作,直到寻找到E或者所有条目均以被检查过。

    FL2:[搜索叶子结点以找到记录] 如果T是叶子结点,那么检查每一个条目是否有E存在,如果有则返回T。

     

    Function:CondenseTree

    描述:L为包含有被删除条目的叶子结点。如果L的条目数过少(小于要求的最小值m),则必须将该叶子结点L从树中删除。经过这一删除操作,L中的剩余条目必须重新插入树中。此操作将一直重复直至到达根结点。同样,调整在此修改树的过程所经过的路径上的所有结点对应的矩形大小。

    CT1:[初始化] 令N为L。初始化一个用于存储被删除结点包含的条目的链表Q。

    CT2:[找到父条目] 如果N为根结点,那么直接跳转至CT6。否则令P为N 的父结点,令EN为P结点中存储的指向N的条目。

    CT3:[删除下溢结点] 如果N含有条目数少于m,则从P中删除EN,并把结点N中的条目添加入链表Q中。

    CT4:[调整覆盖矩形] 如果N没有被删除,则调整EN.I使得其对应矩形能够恰好覆盖N中的所有条目所对应的矩形。

    CT5:[向上一层结点进行操作] 令N等于P,从CT2开始重复操作。

    CT6:[重新插入孤立的条目] 所有在Q中的结点中的条目需要被重新插入。原来属于叶子结点的条目可以使用Insert操作进行重新插入,而那些属于非叶子结点的条目必须插入删除之前所在层的结点,以确保它们所指向的子树还处于相同的层。

     

          R树删除记录过程中的CondenseTree操作是不同于B树的。我们知道,B树删除过程中,如果出现结点的记录数少于半满(即下溢)的情况,则直接把这些记录与其他叶子的记录“融合”,也就是说两个相邻结点合并。然而R树却是直接重新插入。

     

    同样,我们用图直观的说明这个操作。

     

    假设结点最大条目数为4,最小条目数为2。在这张图中,我们的目标是删除记录c。首先使用FindLeaf操作找到c所处在的叶子结点的位置——R11。当c从R11删除时,R11就只有一条记录了,少于最小条目数2,出现下溢,此时要调用CondenseTree操作。这样,c被删除,R11剩余的条目——指向记录d的指针——被插入链表Q。然后向更高一层的结点进行此操作。这样R12会被插入链表中。原理是一样的,在这里就不再赘述。

    有一点需要解释的是,我们发现这个删除操作向上传递之后,根结点的条目R1也被插入了Q中,这样根结点只剩下了R2。别着急,重新插入操作会有效的解决这个问题。我们插入R3,R12,d至它原来所处的层。这样,我们发现根结点只有一个条目了,此时根据Inert中的操作,我们把这个根结点删除,它的孩子结点,即R5,R6,R7,R3所在的结点被置为根结点。至此,删除操作结束。

     

    结语

          R树是一种能够有效进行高维空间搜索的数据结构,它已经被广泛应用在各种数据库及其相关的应用中。但R树的处理也具有局限性,它的最佳应用范围是处理2至6维的数据,更高维的存储会变得非常复杂,这样就不适用了。近年来,R树也出现了很多变体,R*树就是其中的一种。这些变体提升了R树的性能,感兴趣的读者可以参考相关文献。文章有任何错误,还望各位读者不吝赐教。本文完。

     

    参考文献以及推荐阅读:

    1.   Organization and Maintenance of Large Ordered Indices

    2.   the ubiquitous B tree

    3.   http://en.wikipedia.org/wiki/Btree (给出了国外一些开源地址)

    4.   http://en.wikipedia.org/wiki/Btree#Technical_description

    5.   http://cis.stvincent.edu/html/tutorials/swd/btree/btree.htmlinclude C++ source code

    6.   http://slady.net/java/bt/view.php(如果了解了B-tree结构,该地址可以在线对该结构进行查找(search),插入(insert),删除(delete)操作。)
    7. Guttman, A.; “R-trees: a dynamic index structure for spatial searching,” ACM, 1984, 14

    8. http://www.cnblogs.com/CareySon/archive/2012/04/06/2435349.html

    9. http://baike.baidu.com/view/298408.htm

    10. http://www.cnblogs.com/leoo2sk/archive/2011/07/10/mysql-index.html (介绍了mysql中myisam和innodb这两种引擎的内部索引机制,以及对不同字段的索引时,检索效率上的对比,主要也是基于其内部机制的理解)

    11. http://www.oschina.net/news/31988/mysql-indexing-best-practices (MySQL 索引最佳实践);

    12. http://idlebox.net/2007/stx-btree/(此页面包含B树生成构造的一些演示demo)。

    展开全文
  • B+数据库索引中的应用

    千次阅读 2018-05-05 14:37:19
    目前大部分数据库系统及文件系统都采用B-Tree或其变种B+Tree作为索引结构(更少的磁盘I/O操作次数的渐进复杂度) 一般来说,索引本身也很大,不可能全部存储在内存中,因此索引往往以索引文件的形式存储的磁盘上。...
  • 索引是提高数据库表访问速度的方法。 分为聚集索引和非聚集索引。 聚集索引:对正文内容按照一定规则排序的目录。 非聚集索引:目录按照一定的顺序排列,正文按照另一种顺序排列,目录与正文之间保持一种映射关系...
  • 探索B树/B+树与MySQL数据库索引的关系

    万次阅读 多人点赞 2016-11-18 17:40:21
    本文主要讲述主轴线: 由搜索/查找联系到数据...前言:目前大部分数据库系统及文件系统都采用B-Tree或其变种B+Tree作为索引结构,最近学习了数据结构这一部分的内容,又阅读了前辈们关于这一话题的的总结后,斗胆运用
  • B树数据库的结合(很不错)

    千次阅读 2012-08-07 10:23:52
    B- 1 .B-定义 B-是一种平衡的多路查找,它在文件系统中很有用。 定义:一棵m 阶的B-,或者为空,或为满足下列特性的m 叉: ⑴中每个结点至多有m 棵子树; ⑵若根结点不是叶子结点,则至少有...
  • 今天是关于数据库索引,以及具体的实现B树及B+树) 本文参考自两篇博客(个人认为是最好的相关博客了) 数据库索引部分:http://blog.csdn.net/weiliangliang111/article/details/51333169 B树、B+树、B*树以及...
  • B+数据库索引

    千次阅读 2017-03-31 19:41:37
    本文对两篇文章进行了提取总结: ... ... 一、innodb存储引擎索引概述: innodb存储引擎支持两种常见的索引:B+索引和哈希索引。 innodb支持哈希索引是自适应的,innodb会根据表的使
  • 索引是提高数据库表访问速度的方法。 分为聚集索引和非聚集索引。 聚集索引:对正文内容按照一定规则排序的目录。 非聚集索引:目录按照一定的顺序排列,正文按照另一种顺序排列,目录与正文之间保持一种映射关系...
  • B-B+的应用:数据搜索和数据库索引

    万次阅读 多人点赞 2012-07-29 11:27:03
    B- 1 .B-定义:有序数组+平衡多叉 B-是一种平衡的多路查找,它在文件系统中很有用。 定义:一棵m 阶的B-,或者为空,或为满足下列特性的m 叉: ⑴中每个结点至多有m 棵子树; ⑵若根结点不是...
  • 数据库索引及B树、B+树详解

    千次阅读 2018-08-30 21:34:14
    B树、B+树、B*树以及R树参考:http://blog.csdn.net/v_JULY_v/article/details/6530142/   现在进入第一块内容:什么是数据库索引?     我们通过一个简单的例子来开始教程,解释为什么我们需...
  • 数据库索引、B树、B+树

    千次阅读 2014-04-03 17:10:56
    索引的实现通常使用B树及其变种B+树。 在数据之外,数据库系统还维护着满足特定查找算法的数据结构,这些数据结构以某种方式引用(指向)数据,这样就可以在这些数据结构上实现高级查找算法。这种数据结构,就是...
  • 利用BST实现一个城市数据库

    万次阅读 2019-04-27 14:58:18
    利用BST实现一个城市数据库TaskFeatureCodeBST(With balance function)CityDBmain Task 利用BST实现一个城市数据库:每个数据库结点包括城市名称和以整数x与y表示的城市坐标,根据城市名称组织该BST; 在该数据库...
  • 结合B+,谈数据库的联合索引

    千次阅读 2018-05-10 10:32:09
    数据库表T有A,B,C三个字段,对其建立联合索引uniq(A,B,C),请问如下查询哪些会用到索引? 1. SELECT * FROM T WHERE A=a AND B=b AND C=c; 2. SELECT * FROM T WHERE A=a AND B=b; 3. SELECT * FROM T WHERE A=...
  • B+数据库中的应用 { 为什么使用B+?言简意赅,就是因为: 1.文件很大,不可能全部存储在内存中,故要存储到磁盘上 2.索引的结构组织要尽量减少查找过程中磁盘I/O的存取次数(为什么使用B-/+Tree,还跟磁盘存取...
  • B+树比B树更适合做文件数据库索引

    千次阅读 2018-03-16 19:44:10
    B树: B+树: B*树是B+树的变体,在B+树的非根和非叶子结点再增加指向兄弟的指针; B树和B+树在结构上的区别 1. B树中关键字集合分布在整棵树中,叶节点中不包含任何关键字信息,而B+树关键字集合分布在...
  • 数据库索引原理 b树

    千次阅读 2018-05-17 09:49:38
    1 .B-定义B-是一种平衡的多路查找,它在文件系统中很有用。定义:一棵m 阶的B-,或者为空,或为满足下列特性的m 叉:⑴中每个结点至多有m 棵子树;⑵若根结点不是叶子结点,则至少有两棵子树;⑶除根...
  • 数据库索引的数据结构——B-/B+

    千次阅读 2018-08-14 20:28:39
    我们知道,数据库查询是数据库的最主要功能之一。我们都希望查询数据的速度能尽可能的快,因此数据库系统的设计者会从查询算法的角度进行优化。那么有哪些查询算法可以使查询速度变得更快呢? 1. 顺序查找(linear ...
  • 数据库索引为什么使用B树(B+树)

    千次阅读 2019-03-25 21:20:43
    动态查找树主要包括:二叉搜索树、平衡二叉树、红黑树、B树,通过对树高度的降低可以提升查找效率。 B树定义: 一颗m阶的B树满足下列条件: (1)每个节点至多有m棵子树 (2)除根节点外,其他每个分支节点至少有...
  • 数据库为什么要用B+结构-

    万次阅读 2017-06-13 00:26:01
    B+数据库中的应用 { 为什么使用B+?言简意赅,就是因为: 1.文件很大,不可能全部存储在内存中,故要存储到磁盘上 2.索引的结构组织要尽量减少查找过程中磁盘I/O的存取次数(为什么使用B-/+Tree,还跟磁盘...
  • 查找(二)简单清晰的B树、Trie树详解 (原文http://blog.csdn.net/yang_yulei/article/details/26104921) 分类: 数据结构 算法2014-05-18 00:05 2885人阅读 评论(2) 收藏 举报 目录(?)[+] ...
  • 2. 所谓索引,即是快速定位与查找,那么索引的结构组织要尽量减少查找过程中磁盘I/O的存取次数(B+树相比B树,其非叶子节点占用更小的空间) 3. 局部性原理与磁盘预读,预读的长度一般为页(page)的整倍数,(在许多操作...
  • 数据库系统——B+索引

    万次阅读 多人点赞 2013-09-01 22:58:33
    1. B+索引概述 在上一篇文章中,我们讨论了关于index的几个中重要的课题: A) index是保存在磁盘上的一种数据结构,用于提高查询或是扫描record的速度。 B) 排序索引通过保存page的指针加速record的查找。...
  • 在关系数据库中,索引是一种单独的、物理的对数据库表中一列或多列的值进行排序的一种存储结构,它是某个表中一列或若干列值的集合和相应的指向表中物理标识这些值的数据页的逻辑指针清单。索引的作用相当于图书的...
  • 在本文中,我们以 InnoDB 为例,介绍 MySQL 的索引结构以及其使用 B+ 树实现索引的原因。 表空间 首先,来了解一下 MySQL 的表空间。中的所有数据被存储在一个空间内,称之为表空间,表空间内部又可以分为段(segment...
  • 利用ZTree链接数据库实现 [权限管理]

    千次阅读 2016-11-17 17:21:14
    最近想研究权限管理,看群里有人发了ZTrees模板...刚开始从网上找了找了个Demo,当然这个并没有实现权限啥的,但实现了前台调用Ajax给后台传递数据,这就有思路了,那个我单独整理了一片博文,可以在看这篇博文前先看看...
  • 数据库为什么要用B+结构

    千次阅读 2018-04-23 09:20:37
    B+数据库中的应用{为什么使用B+?言简意赅,就是因为:1.文件很大,不可能全部存储在内存中,故要存储到磁盘上2.索引的结构组织要尽量减少查找过程中磁盘I/O的存取次数(为什么使用B-/+Tree,还跟磁盘存取原理...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 80,419
精华内容 32,167
关键字:

利用b树实现数据库