B树

首先本文参考了其他一些博客，在此列出，表示感谢：

　　http://blog.csdn.net/v_july_v/article/details/6530142

 　   http://blog.csdn.net/mishifangxiangdefeng/article/details/7798672

（一）m叉搜索树

　　在讨论B树之前，首先我们来讨论m叉搜索树，所谓m叉搜索树是这样定义的：

　　对于内部节点（非叶子节点），它含有n个键值k_1, k₂,  ... , k_n 和 n+1个儿子节点s₀, s₁,  ... , s_n（其中1 <= k <= m -1）

　　且满足：

　　　　(i)　k₁ < k₂ <  ...  < k_n,键值k是递增序列

　　　　(ii) 　对于任意一个儿子节点 s_i　，以s_i为根节点的子树中的所有键值都要大于k_i小于k_ｉ＋１

　　对于外部节点（叶子节点），不含任何键值和儿子节点指针

　　其实上面的定义虽然拗口晦涩，但是实际上确很简单，如果m=2，那么就是一颗简单的BST了，所以可以借助BST来思考m

叉搜索树的样子，这里为了帮助理解，画出一颗4叉搜索树如下：

　　

　　　　图中蓝色节点为内部节点，白色节点为外部节点，内部节点中的数值为键值

（二）B-Tree

　　（１）定义

　　　　介绍完m叉搜索树之后，现在我们来看一下m阶Ｂ树的定义：

　　　　１）m阶B树是一颗m叉搜索树

　　　　２）除了根节点以外，所有内部节点都至少含有UP(m/2)个孩子，　　UP是取上界函数

　　　　３）所有外部节点都在同一层次　　

　　

　　所以可以看到, B树其实就是一种特殊的m叉搜索树，它的特殊意义在于一是限定内部节点的孩子不能太少，而是限定所有外部节点位于同一层

换句话说就是保证树是平衡的

　　　　　　　　　　　　　

 　　　　　　　　　　　　　　　　　　　　　　　　５阶B树（最底层为叶子节点，这里省略）

　　（２）性质

　　　　根据B树的定义，我们可以得到相关性质如下：

　　　　１）如果一颗ｍ阶B树存储的总键值数目为n,　　设根节点高度为０，　d = UP(m/2)

　　　　　　 那么B树的高度最差情况下（值最大）是 log_d ^[(n ＋ 1) / 2] + 1

　　　　　　　　B树高度最优情况下（值最小）是 log_m (n + 1)  + 1

 　　　　这里证明一下最坏情况下的高度：

　　　　　　最坏情况就是跟节点只有两个儿子，而其他内部节点只有d = UP(m/2)个儿子，那么设树高度为h，总键值数目有n个

　　　　则，０层键值有１个

　　　　　　１层有２＊（d-1）个

　　　　　　２层有2*（d-1）^2个

　　　　　　...

　　　　　　h-1层有2*（d-1）^(h-1)个

　　　　　　h层都是外部节点所以为0个

　　　　　　

　　　　　那么　1 + 2(d-１) + 2(d-1)^2 + ... + 2(d-1)^(h-1) = 1 + 2[(d-1) + (d-1)^2 + ... + (d-1)^(h-1)]

　　　　　　　　　　　　　　　　　　　　　= 1 + 2(d-1) * (1 - d^h-1) / ( 1 - d)   ,

　　　　　　　　　　　　　　　　　　　　　= 1 + 2*(d^h-1 - 1)

　　　　　　　　　　　　　　　　　　　　　= 2*d^h-1 - 1 = n

　　　　　=> h =  log_d ^[(n ＋ 1) / 2] + 1

　　　　　　　　　　　　　　　　　　　　　　　　

　　（３）结构

　　　　根据上面的定义，可以清楚的得到B树的节点结构形式：　　

 // B-Tree节点，按照算法导论中的定义
struct BTreeNode{
        BTreeNode* parent; //父亲节点
　　 　　int rank;     // 节点在父亲节点中childs的位置 ，这个值一般来说没什么用，可以不用管它，只是在下面的删除操作时候会用到
        int nums;　// keys个数
        list<int> keys;
        list<BTreeNode*> childs;
        BTreeNode(int nums):nums(nums){ }
};   

　　（４）　树的基本操作

　　i)查找：

　　　　给定一个key查找出包含这个key的节点，如果不存在返回叶子节点

　　

//find函数内部实现函数
BTreeNode* BTree::_find(int key, BTreeNode *node){                         
    if(!node->nums) return node; 
    list<int>::iterator iter_k = node->keys.begin();
    list<BTreeNode*>::iterator iter_c = node->childs.begin();              
    while(iter_k != node->keys.end() && key >= *iter_k){                   
        if(key == *iter_k)  return node;         // 找到key值，返回节点                          
        iter_k++;                                                          
        iter_c++;                                                          
    }
    BTreeNode *ret = _find(key, *iter_c);   // 递归搜索子树                               
    return ret;                                                            
}                                                                          

//查找时间为O(h*m) + h次访问节点时间(在磁盘模型中就是访问磁块的时间)
BTreeNode* BTree::find(int key){
    BTreeNode* ret = _find(key, root);                                     
    return ret;                                                            
} 

　　　　从查找函数的时间分析，可以看出在m阶B树查找一个key值,在内存中操作时间花费为Ｏ(h*m), 　访问节点数目为h个，如果这数据量特别大，

整个树的节点内容只能保存到磁盘中，那么每次访问一个节点就是读取一个磁块，假设访问一次磁盘读取一个磁块所花时间为t_m，那么整个find函数

磁盘访问花费时间为　　h*t_m

　　所以总时间 　　Ｔ = O(h*m) + h * t_m

　　我们知道访问磁盘时候，寻址时间非常的漫长，所以每一次读取一个磁块的时间都是远远大于在内存中对这块磁块中数据操作所花的时间，

即t_m  >> O(m)，所以可以看到T的大小主要受树的高度h影响，这也就是为什么在那些磁盘检索内容的场景中（比如数据库）非常喜欢使用B树来组织了，

因为树的高度要比红黑树等低很多，所以磁盘花费的时间就少很多．

　　

　　ii)插入

　　　　在B树中插入一个key

　　对于插入操作，首先是find整个树看一下是否已经存在key，如果存在那么不做任何操作，如果不存在，那么find函数会返回一个外部节点L，

那么将这个key插入到该外部节点的父亲节点P中，这是其父亲节点P的key数目会增加１，有可能会达到m,违反节点树存储键值最大不超过m-1个原则，

那么就需要对它进行拆分，此时我们知道该节点P有m个key值，所以可以把第m/2个key放入P的父亲节点Q中，然后前m/2个key值组成一个节点，

后m/2个key值组成一个节点，这样Q的key值数目也可能超标，需要递归的调整．

　　相关伪代码如下：

　　　　

//插入函数
void BTree::insert(int key){
    if(root->nums == 0){ // 树现在为空
        root->keys.push_back(key);
        root->childs.push_back(new BTreeNode(0, root));
        root->childs.push_back(new BTreeNode(0, root));
        root->nums++;
        return;
    }
    BTreeNode *node = find(key);
    if(node->nums == 0){ // key 确实不存在树中
        BTreeNode *parent = node->parent; // parent节点是要插入的节点
        list<int>::iterator iter = parent->keys.begin();
        list<BTreeNode*>::iterator iter_c = parent->childs.begin();
        while(iter != parent->keys.end() && key > *iter){ // 寻找插入位置
            iter++;
            iter_c++;
        }
        parent->keys.insert(iter, key); // 插入进去
        iter_c++;
        parent->childs.insert(iter_c, new BTreeNode(0, parent));
        parent->nums++;
        if(parent->nums == m){ // 插入之后key值爆满，需要调整
            adjust(parent);
        }
    }
}

　　下面是调整函数

//调整函数
void BTree::adjust(BTreeNode *node){
    BTreeNode *parent = node->parent;
    if(!parent){// node节点是根节点
        int mid = (node->nums)/2;
        list<int>::iterator iter_k = node->keys.begin();
        list<BTreeNode*>::iterator iter_c = node->childs.begin();
        BTreeNode *left = new BTreeNode(), *right = new BTreeNode(); // 拆分后的两个新节点
        for(int i = 0; i < mid; iter_k++, iter_c++, i++){//拆分, 前一半弄成坐便节点
            left->nums++;
            left->keys.push_back(*iter_k);
            left->childs.push_back(*iter_c);
            (*iter_c)->parent = left;
        }
        left->childs.push_back(*iter_c);
        (*iter_c)->parent = left;
        iter_c++;
        BTreeNode *newroot = new BTreeNode();//由于node是根节点，需要重新生成新跟节点
        newroot->keys.push_back(*iter_k);
        newroot->childs.push_back(left);
        newroot->childs.push_back(right);
        newroot->nums = 1;
        left->parent = newroot;
        right->parent = newroot;
        iter_k++;
        for(; iter_k != node->keys.end(); iter_k++, iter_c++){//后一半弄成右边节点
            right->nums++;
            right->keys.push_back(*iter_k);
            right->childs.push_back(*iter_c);
            (*iter_c)->parent = right;
        }
        right->childs.push_back(*iter_c);
        (*iter_c)->parent = right;


        //delete node;
        root = newroot;
        return;
    }else{// node　并非是根节点
        int mid = (node->nums)/2;
        list<int>::iterator iter_k = node->keys.begin();
        list<BTreeNode*>::iterator iter_c = node->childs.begin();
        BTreeNode *left = new BTreeNode(), *right = new BTreeNode();
        for(int i = 0; i < mid; iter_k++, iter_c++, i++){// 拆分
            left->nums++;
            left->keys.push_back(*iter_k);
            left->childs.push_back(*iter_c);
            (*iter_c)->parent = left;
        }
        left->childs.push_back(*iter_c);
        (*iter_c)->parent = left;
        iter_c++;
        list<int>::iterator iter_pk = parent->keys.begin();
        list<BTreeNode*>::iterator iter_pc = parent->childs.begin();
        while(iter_pk != parent->keys.end() && *iter_k > *iter_pk){
            iter_pk++;
            iter_pc++;
        }
        parent->keys.insert(iter_pk, *iter_k);
        *iter_pc = right;
        parent->childs.insert(iter_pc, left);
        parent->nums++;
        left->parent = parent;
        right->parent = parent;
        iter_k++;
        for(; iter_k != node->keys.end(); iter_k++, iter_c++){
            right->nums++;
            right->keys.push_back(*iter_k);
            right->childs.push_back(*iter_c);
            (*iter_c)->parent = right;
        }
        right->childs.push_back(*iter_c);
        (*iter_c)->parent = right;

        if(parent->nums == m)// 继续向上调整
            return adjust(parent);
    }
}

　　iii)删除

　　B树的删除节点十分的复杂，这里简单介绍一下具体方法：

* 情况１: 要删除的key所在B树的节点其子节点不是外部节点，即不是最低层的内部节点．这种情况就可以寻在此key的前驱或者后继，然后与器交换值，

再删除其前驱或者后继，则转化为情况２． 
* 情况２：要删除的key所在B树的节点是最低层的内部节点． 
* *　情况2a: 此节点所含key的数量大于B树的节点key数量下限，这种情况下由于直接删除此key，对该节点的key数量造成－１后还是满足大于等于key数量

最低数量的要求，所以可以直接删掉次key值． 
* *　情况2b：此节点所含key数量正好为下限，但是其节点的兄弟节点（左兄弟或者右兄弟）所含key数量大于下限，则可以通过转移的手段，把兄弟节点的某个

key移到其父亲节点，然后父亲节点的某个key移到该节点． 
* *　情况2c: 此节点所含key数量正好为下限且节点左右兄弟所含key数量也是下限，这时候需要跟左／右节点合并，然后再递归调整父亲节点．

相关代码如下:

void BTree::adjustLessRoot(){//调整根节点
    root = root->childs.front();
    root->parent = NULL;
}

void BTree::_findIterator(BTreeNode *node, Key_Iter &iter_k, Childs_Iter &iter_c){// 寻找node节点所在父亲节点的位置
    if(node == root)    return;
    if(node->nums == 0){
        BTreeNode *parent = node->parent;
        iter_k = parent->keys.begin();
        iter_c = parent->childs.begin();
        while(node->rank-- > 0){
            iter_k++;
            iter_c++;
        }
        return;
    }
    BTreeNode *parent = node->parent;
    iter_k = parent->keys.begin();
    iter_c = parent->childs.begin();
    int key = node->keys.front();
    while(iter_k != parent->keys.end() && key > *iter_k){
        iter_k++;
        iter_c++;
    }
}

bool BTree::adjustLessBrother(BTreeNode *node){// 情况２具体调整
    BTreeNode *parent = node->parent;
    Key_Iter iter_pk;
    Childs_Iter iter_pc;
    _findIterator(node, iter_pk, iter_pc);
    if(iter_pk != parent->keys.begin()){ // 有左兄弟
        iter_pc--;
        BTreeNode *left = *iter_pc;
        iter_pc++;
        if(left->nums > up - 1){ // 情况2b
            iter_pk--;
            node->keys.push_front(*iter_pk);
            node->childs.push_front(left->childs.back());
            node->nums++;
            *iter_pk = left->keys.back();
            left->childs.pop_back();
            left->keys.pop_back();
            left->nums--;
            node->childs.front()->parent = node;
            iter_pk++;
            return true;
        }
    }
    if(iter_pk != parent->keys.end()){ // 有右兄弟
        iter_pc++;
        BTreeNode *right = *iter_pc;
        iter_pc--;
        if(right->nums > up - 1){    // 情况2b
            node->keys.push_back(*iter_pk);
            node->childs.push_back(right->childs.front());
            node->nums++;
            *iter_pk = right->keys.front();
            right->childs.pop_front();
            right->keys.pop_front();
            right->nums--;
            node->childs.back()->parent = node;
            return true;
        }
    }
    if(parent->nums == 1 && parent->parent){
        Key_Iter iiter = parent->parent->keys.begin();
        int key = parent->keys.front();
        parent->rank = 0;
        while(iiter != parent->parent->keys.end() && key > *iiter){
            iiter++;
            parent->rank++;
        }
    }
    // 情况2c
    if(iter_pk != parent->keys.begin()){ // 有左兄弟
        iter_pc--;
        BTreeNode *left = *iter_pc;
        iter_pc++;
        iter_pk--;
        left->keys.push_back(*iter_pk);
        left->keys.insert(left->keys.end(), node->keys.begin(), node->keys.end());
        left->childs.insert(left->childs.end(), node->childs.begin(), node->childs.end());
        left->nums = left->nums + 1 + node->nums;
        iter_pk++;
        parent->keys.erase(iter_pk);
        parent->childs.erase(iter_pc);
        parent->nums--;
        for(Childs_Iter  iter_c = node->childs.begin(); iter_c != node->childs.end(); iter_c++){
            (*iter_c)->parent = left;
        }
    }else{ // 有右兄弟
        iter_pc++;
        BTreeNode *right = *iter_pc;    
        node->keys.push_back(*iter_pk);
        node->keys.insert(node->keys.end(), right->keys.begin(), right->keys.end());
        node->childs.insert(node->childs.end(), right->childs.begin(), right->childs.end());
        node->nums = node->nums + 1 + right->nums;
        parent->keys.erase(iter_pk);
        parent->childs.erase(iter_pc);
        iter_pc--;
        parent->nums--;
        for(Childs_Iter iter_c = right->childs.begin(); iter_c != right->childs.end(); iter_c++){
            (*iter_c)->parent = node;
        }
    }
    if(parent->nums < up - 1)
        adjustLess(parent);
}

void BTree::adjustLess(BTreeNode *node){//调整
    if(node == root){ // root为空
        if(node->nums)    return;
        adjustLessRoot();
        return;
    }
    adjustLessBrother(node); // 情况2
}

void BTree::_removeExternal(int key, BTreeNode *node){// 情况２
    if(node == root && root->nums == 1){
        node->keys.clear();
        node->childs.clear();
        node->nums = 0;
        return;
    }
    list<int>::iterator iter_k = node->keys.begin();
    list<BTreeNode*>::iterator iter_c = node->childs.begin();
    while(*iter_k != key && iter_k != node->keys.end()){
        iter_k++;
        iter_c++;
    }
    node->keys.erase(iter_k);    //　默认情况2a 
    node->childs.erase(iter_c);
    node->nums--;
    if(node->nums < up - 1){// 转至情况2b,2c
        adjustLess(node);
    }
}

BTreeNode* BTree::_getMax(BTreeNode *node){
    if(node->childs.front()->nums == 0)    return node;
    return _getMax(node->childs.back());
}
void BTree::remove(int key){// remove函数
    BTreeNode *node = find(key);
    if(!isLeaf(node)){
        list<int>::iterator iter_k = node->keys.begin();
        list<BTreeNode*>::iterator iter_c = node->childs.begin();
        while(*iter_k != key && iter_k != node->keys.end()){
            iter_k++;
            iter_c++;
        }
        if(isLeaf(*iter_c)){
            _removeExternal(key, node); // 情况2
        }else{
            BTreeNode* max;
            if(iter_k == node->keys.begin()){ // 与后继交换
                iter_c++;
                max = _getMax(*iter_c);
                *iter_k = max->keys.front();
                _removeExternal(max->keys.front(), max); // 转为情况2
            }
            else{ // 与前驱交换
                max = _getMax(*iter_c);
                *iter_k = max->keys.back();
                _removeExternal(max->keys.back(), max);
            }
        }
    }
}

（三）B+Tree

　　B+树是B树的改进版本，这里介绍一下它与B树的差别：

      １. 所有的最底层内部节点结点中包含了全部关键字的信息，及指向含有这些关键字记录的指针，且这些结点本身依关键字的大小自小而大的顺序链接。 

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

　　　　　　　　　　　　　　 

　　　　

　　　　note:     为什么说B⁺-tree比B 树更适合实际应用中操作系统的文件索引和数据库索引？（这里引用July的博客）

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

　　　　B⁺-tree的内部结点并没有指向关键字具体信息的指针。因此其内部结点相对B 树更小。如果把所有同一内部结点的关键字存放在同一盘块中，

那么盘块所能容纳的关键字数量也越多。一次性读入内存中的需要查找的关键字也就越多。相对来说IO读写次数也就降低了。

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

　　　　由于非终结点并不是最终指向文件内容的结点，而只是叶子结点中关键字的索引。所以任何关键字的查找必须走一条从根结点到叶子结点的路。

所有关键字查询的路径长度相同，导致每一个数据的查询效率相当。

　　　　　　３)其他原因

　　　　数据库索引采用B+树的主要原因是 B树在提高了磁盘IO性能的同时并没有解决元素遍历的效率低下的问题。正是为了解决这个问题，B+树应运

而生。B+树只要遍历叶子节点就可以实现整棵树的遍历。而且在数据库中基于范围的查询是非常频繁的，而B树不支持这样的操作（或者说效率太低）。

（四）B*Tree

　　　　B*-tree是B⁺-tree的变体，在B⁺树的基础上(所有的最底层结点中包含了全部关键字的信息，及指向含有这些关键字记录的指针)，B*树中非根和

非最底层结点再增加指向兄弟的指针；B*树定义了非叶子结点关键字个数至少为(2/3)*M，即块的最低使用率为2/3（代替B+树的1/2）