B树的插入

一、B树的定义

1970年，R. Bayer和E.m ccreight 提出了一种适合外查找的树，它是一种平衡的多叉树，称为B树，有些地方写的是B-树，注意不要误读成"B减树"）

1、B树（B-tree）是对2-3树数据结构的扩展，又称为多路平衡查找树，它的一个节点可以拥有多于2个子节点的二叉查找树。与自平衡二叉查找树不同

2、B树是一种自平衡树数据结构，可以保持数据排序，它能够存储数据、对其进行排序并允许以O(log n)的时间复杂度运行进行查找、顺序读取、插入和删除的数据结构

3、B树针对读写大数据块的系统进行了优化。B树的算法减少定位记录时所经历的中间过程，从而加快存取速度。普遍运用在数据库和文件系统。

二、B树的性质

一棵M阶(M>2)的B树，是一棵平衡的M路平衡搜索树，可以是空树或者满足一下性质：

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

2. 每个非根节点至少有M/2(上取整)个孩子,至多有M 个孩子 3. 每个非根节点至少有M/2-1( 上取整)个关键字,至多有M-1个关键字，并且以升序排列

4. key[i]和key[i+1]之间的孩子节点的值介于key[i ]、key[i+ 1]之间

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

三、B树的插入

步骤：

1、插入一个元素时，首先在B树中是否存在，如果不存在，即比较大小寻找插入位置，在叶子结点处结束，然后在叶子结点中插入该新的元素

2、如果叶子结点空间足够，这里需要向右移动该叶子结点中大于新插入关键字的元素，如果空间满了以致没有足够的空间去添加新的元素，则将该结点进行“分裂”，将一半数量的关键字元素分裂到新的其相邻右结点中，中间关键字元素上移到父结点中（当然，如果父结点空间满了，也同样需要“分裂”操作）

3、当结点中关键元素向右移动了，相关的指针也需要向右移。如果在根结点插入新元素，空间满了，则进行分裂操作，这样原来的根结点中的中间关键字元素向上移动到新的根结点中，因此导致树的高度增加一层

eg：M阶B树--M=3

{53 , 75 , 139 , 49, 145, 36, 101};

插入36：

插入101后还需要分裂。

代码：

#include<iostream>
using namespace std;

template<class K,int M=3>
struct BTreeNode
{
  BTreeNode()
  :_pParent(NULL)
  , _size(0)
  {
    for (size_t i = 0; i <= M; i++)
    {
      _pSub[i] = NULL;
    }
  }

  K _key[M];
  BTreeNode<K, M> *_pSub[M + 1];
  BTreeNode<K, M> *_pParent;
  size_t _size;
};

template<class K,int M=3>
class BTree
{
  typedef BTreeNode<K, M> Node;
  typedef Node* pNode;
public:
  BTree()
    :_pRoot(NULL)
  {}

  bool Insert(K& key)
  {
    if (_pRoot == NULL)     //无根节点
    {
      _pRoot = new Node();
      _pRoot->_key[0] = key;
      _pRoot->_size = 1;
      return true;
    }

    pair<pNode, int> ret = Find(key);
    if (ret.second >= 0)
      return false;
    pNode pCur = ret.first;
    pNode pSub = NULL;
    while (1)
    {
      _Insert(pCur, key, pSub);
      size_t size = pCur->_size;
      if (size < M)
        return true;
      else
      {
        size_t mid = size >> 1;
        pNode tmp = new Node();
        for (size_t i= mid + 1; i < size; i++)
        {
          tmp->_key[tmp->_size] = pCur->_key[i];
          tmp->_pSub[tmp->_size] = pCur->_pSub[i];
          if (tmp->_pSub[tmp->_size])
            tmp->_pSub[tmp->_size]->_pParent = tmp;
          tmp->_size++;
        }
        tmp->_pSub[tmp->_size] = pCur->_pSub[pCur->_size];

        if (tmp->_pSub[tmp->_size])
          tmp->_pSub[tmp->_size]->_pParent = tmp;
        pCur->_size -= (tmp->_size + 1);               //处理size

        if (pCur == _pRoot)                            //如果当前结点是根结点，还需要再处理
        {
          _pRoot = new Node;
          _pRoot->_key[0] = pCur->_key[mid];
          _pRoot->_pSub[0] = pCur;
          pCur->_pParent = _pRoot;
          _pRoot->_pSub[1] = tmp;
          tmp->_pParent = _pRoot;
          _pRoot->_size = 1;
          return true;
        }
        else
        {
          key = pCur->_key[mid];
          pCur = pCur->_pParent;
          pSub = tmp;
        }
      }
    }
  }

  pair<pNode, int> Find(const K& key)
  {
    pNode pCur = _pRoot;
    pNode pParent = NULL;

    while (pCur)
    {
      size_t i = 0;
      while (i < pCur->_size)
      {
        if (key == pCur->_key[i])
          return pair<pNode, int>(pCur, i);
        else if (key < pCur->_key[i])
          break;
        else
          i++;
      }
      pParent = pCur;
      pCur = pCur->_pSub[i];
    }
    return make_pair(pParent, -1);//没找到返回-1
  }
private:
  void _Insert(pNode pCur, const K& key, pNode pSub)
  {
    //直接插入的思想
    int end = pCur->_size - 1;
    while (key < pCur->_key[end] && end >= 0)
    {
      pCur->_key[end + 1] = pCur->_key[end];
      pCur->_pSub[end + 2] = pCur->_pSub[end + 1];
      end--;
    }

    pCur->_key[end + 1] = key;
    pCur->_pSub[end + 2] = pSub;
    if (pSub)
      pSub->_pParent = pCur;
    pCur->_size += 1;
  }
private:
  Node *_pRoot;
};

int main()
{
  int arr[] = { 53, 75, 139, 49, 145, 36, 101 };
  BTree<int> b;
  size_t size = sizeof(arr) / sizeof(arr[0]);
  for (size_t i = 0; i < 7; i++)
    b.Insert(arr[i]);

  system("pause");
  return 0;
}