前言：

一、B树

1、B树概念

2、B树查找

3、B树插入

4、B树前序遍历

5、B树性能

二、B+、B*树

1、B+树概念

2、B+树的插入

2、B*树概念

3、总结

三、B系列树的应用

总结

前言：

我们已经有很多索引的数据结构了

例如：

顺序查找、二分查找、二叉搜索树、二叉平衡树(AVL树和红黑树) 、哈希

以上结构适合于数据量相对较小，能够一次性存放在内存中，进行数据查找

如果数据量很大，一次性无法放进内存中，那么只能存放到磁盘上，如果要进行搜索，只能将关键字映射的数据的地址存放到搜索树的节点中，要访问数据，就要先去磁盘中读取

磁盘的速度是远低于内存的，虽然平衡搜索树的时间复杂度是O(log H)(H是高度)

100亿个数据也就仅仅需要查找10次，但是这是在内存的情况，10次IO的速度和在内存中查找10次

的速度相差十分的大

哈希表虽然能够达到O(1)但是极端情况下哈希冲突非常严重，效率下降很多

所以为了解决大量数据的查询，在平衡搜索树的基础上提出了B树

B树主要进行了两点优化

1、压缩高度，二叉树变成多叉树

2、一个节点里面有多个关键字及映射的值

一、B树

1、B树概念

1970年，R.Bayer和E.mccreight提出了一种适用于外查找的树，它是一种平衡的多叉树，称为B树（或B-树、B_树）。

一棵m阶B树(balanced tree of order m)是一棵平衡的m路搜索树。它或者是空树，或者是满足下列性质的树：

1. 根节点至少有两个孩子

2. 每个分支节点都包含 k-1 个关键字和 k 个孩子，其中 ceil(m/2) ≤ k ≤ m ceil 是向上取整函数

3. 每个叶子节点都包含 k-1 个关键字，其中 ceil(m/2) ≤ k ≤ m

4. 所有的叶子节点都在同一层

5. 每个节点中的关键字从小到大排列，节点当中 k-1 个元素正好是 k 个孩子包含的元素的值域划 分

6. 每个结点的结构为：（ n ， A0 ， K1 ， A1 ， K2 ， A2 ， … ， Kn ， An ）其中， Ki(1≤i≤n) 为关键

字，且 Ki<Ki+1(1≤i≤n-1) 。 Ai(0≤i≤n) 为指向子树根结点的指针。且 Ai 所指子树所有结点中的关键字均小于Ki+1 。 n为结点中关键字的个数，满足ceil(m/2)-1≤n≤m-1 。

根至少有两个孩子的原因会在分裂时讲解

关键字的个数比孩子的数量少一个

例如M = 10

最少有 4个关键字， 5个孩子

最多有9个关键字，10个孩子

向上取整的原因会在插入时说明

同时每一层的关键字按特定的顺序排列(升序，降序，可以使用仿函数来控制)

2、B树查找

还是以上图为例，现在要找53

寻找的思路与二叉搜索树类型，不过这次是在一个数组中寻找，

它既要在纵向上搜索，也要在横向上搜索

先在横向搜索，从左向右遍历找到与它的key相等的节点，如果不相等比它小，就继续向右遍历

比它小就到下一层寻找，直到找到该节点或者将整棵树遍历完都没有找到

为了提高效率，因为对于每一个节点来说，它是有序的，可以使用二分查找提高查找效率

同时为了方便实现Insert，我们将Find的返回值类型定义为pair<Node*, int>

如果能够找到就返回该节点的地址，及它在该节点位置的下标

找不到就返回它的父节点及-1，可以根据pair的second来判断是否找到该节点

找到它的父节点就可以方便进行插入了

   // 顺序遍历
    std::pair<Node *, int> Find(const K &key)
    {
        Node *cur = _root;
        Node *parent = nullptr;
        while (cur)
        {
            size_t i = 0;
            while (i < cur->_n)
            {
                if (key < cur->_keys[i])
                {
                    break;
                }
                else if (key > cur->_keys[i])
                {
                    i++;
                }
                else
                {
                    return std::make_pair(cur, i);
                }
            }
            parent = cur;
            cur = cur->_subs[i];
        }
        return std::make_pair(parent, -1);
    }

    // 二分查找
    std::pair<Node *, int> Find(const K &key)
    {
        Node *cur = _root;
        Node *parent = nullptr;
        while (cur)
        {
            int left = 0;
            int right = cur->_n - 1;
            while (left <= right)
            {
                int mid = (left + right) >> 1;
                if (key < cur->_keys[mid])
                {
                    right = mid - 1;
                }
                else if (key > cur->_keys[mid])
                {
                    left = mid + 1;
                }
                else
                {
                    return std::make_pair(cur, mid);
                }
            }
            parent = cur;
            cur = cur->_subs[left];
        }
        return std::make_pair(parent, -1);
    }

3、B树插入

B树的插入，如果不考虑分裂是比较简单的

bool Insert(const K &key, const V &val)
    {
        if (_root == nullptr)
        {
            _root = new Node;
            _root->_keys[0] = key;
            _root->_val[0] = val;
            _root->_n++;

            return true;
        }

 

        return true;
    }

接下来看具体的插入过程

   void InsertKey(Node *node, const K &key, const V &val, Node *child)
    {
        int end = node->_n - 1;
        while (end >= 0)
        {
            if (key < node->_keys[end])
            {
                node->_keys[end + 1] = node->_keys[end];
                node->_val[end + 1] = node->_val[end];

                // child 也要对应上
                node->_subs[end + 2] = node->_subs[end + 1];

                end--;
            }
            else
            {
                break;
            }
        }

        // 先插入key
        node->_keys[end + 1] = key;
        node->_val[end + 1] = val;

        // 最后插入child,关键字比节点数少一
        node->_subs[end + 2] = child;
        if (child)
        {
            child->_parent = node;
        }
        node->_n++;
    }

   bool Insert(const K &key, const V &val)
    {
        if (_root == nullptr)
        {
            _root = new Node;
            _root->_keys[0] = key;
            _root->_val[0] = val;
            _root->_n++;

            return true;
        }

        // 插入节点过程
        K newKey = key;
        V newVal = val;
        Node *child = nullptr;
        std::pair<Node *, int> ret = Find(newKey);
        //说明已经存在该节点了，不用插入
        if (ret.second >= 0)
        {
            return false;
        }

        Node *parent = ret.first;
        while (true)
        {
            InsertKey(parent, newKey, newVal, child);
            if (parent->_n < M)
            {
                return true;
            }

            // B树满了，开始分裂，创建新节点，并且将原节点的一半拷贝给brother
            size_t mid = M / 2;
            Node *brother = new Node;
            size_t j = 0;
            size_t i = mid + 1;
            for (; i < M; i++)
            {
                brother->_keys[j] = parent->_keys[i];
                brother->_val[j] = parent->_keys[i];
                brother->_subs[j] = parent->_subs[i];

                // parent->child->parent = brother
                if (parent->_subs[i])
                {
                    parent->_subs[i]->_parent = brother;
                }

                // 处理干净，指针必须处理，val可以不处理
                parent->_keys[i] = K();
                parent->_val[i] = V();
                parent->_subs[i] = nullptr;

                j++;
            }
            // child比key多一个，处理最后的右子树
            brother->_subs[j] = parent->_subs[i];
            if (parent->_subs[i])
            {
                parent->_subs[i]->_parent = brother;
            }
            parent->_subs[i] = nullptr;

            brother->_n = j;
            parent->_n -= j + 1; // 还有一个节点给了parent

            K midKey = parent->_keys[mid];
            K midVal = parent->_val[mid];

            parent->_keys[mid] = K();
            parent->_val[mid] = V();

            //说明刚才分裂的是根节点
            if (parent->_parent == nullptr)
            {
                _root = new Node;
                _root->_keys[0] = midKey;
                _root->_val[0] = midVal;
                _root->_subs[0] = parent;
                _root->_subs[1] = brother;
                _root->_n = 1;

                parent->_parent = _root;
                brother->_parent = _root;
                break;
            }
            else
            {
                // 转化为parent->parent 中插入 newKey和brother
                newKey = midKey;
                newVal = midVal;

                child = brother;
                parent = parent->_parent;
            }
        }

        return true;
    }

4、B树前序遍历

它的前序遍历就是多叉树的前序遍历，同时不要忘记最后的右子树

   void _InOrder(Node *root)
    {
        if (root == nullptr)
        {
            return;
        }
        //左树，根，左树，根，左树，根……
        size_t i = 0;
        for (; i < root->_n; i++)
        {
            _InOrder(root->_subs[i]);
            std::cout << "Key  " << root->_keys[i] << " : "
                      << "val  " << root->_val[i] << std::endl;
        }

        //右数
        _InOrder(root->_subs[i]);
    }

    void InOrder()
    {
        _InOrder(_root);
    }