B+树插入C++的简单实现

B+树的概念不再赘述，偶然得到一题目，原题是在磁盘中进行树的操作，应该是使用文件偏移和定位那个几个函数 ， 这里简单实现了B+树在内存中的插入

先看一下B+树的结构：

定义了非叶子节点和叶子节点，NextLevelPid是指向子节点，IndexEntry中有索引，LeafNode是叶子节点，其中有数据Data和指向下一个叶子节点

class None_Leaf_Node;struct Node{    int pid;    None_Leaf_Node *fatherNode;    virtual ~Node() {}    virtual int getNodeEntrySize() { return 0; }};struct None_Leaf_Node : public Node{    list<Node *> nextLevelNodes;    list<int> keys;    int getNodeEntrySize()    {        return keys.size();    }};struct Leaf_Node : public Node{    map<int, int> keyValues;    Leaf_Node *nextLeafNode;    int getNodeEntrySize()    {        return keyValues.size();    }};

只实现了插入操作， 简单理清一下思路：

1. 初次插入是从叶子节点，当叶子节点中的数据多于每个节点最大存储数量，则分裂
2. 插入时需要寻找插入点，返回可以插入到的叶子节点
3. 分裂是一个递归的过程，从当前要分裂的点一直向上寻找父节点最后到根节点
4. 分裂时考虑父节点是否为空，如果为空new一个非叶子节点，当做根节点，保存叶子节点
5. 有很多情况未测试，见谅

插入：

bool insert(int key, int rid)    {        //刚开始插入的几次 直接在叶子节点插入        if (typeid(*m_RootNode) == typeid(Leaf_Node))        {            //向叶子节点插入            auto itr =  dynamic_cast<Leaf_Node *>( m_RootNode) ->keyValues.insert(pair<int, int>(key, rid));            if (itr.second)            {                cout << "插入成功" << endl;            }            else            {                cout << "插入失败" << endl;                return false;            }            //调整叶子节点            adjustAfterInsert(m_RootNode, 1);            return true;        }        else        {            //先查找然后插入             Leaf_Node *lNode = findInsertPoint(key);            if (lNode->fatherNode == nullptr)            {                return false;            }            auto itr = lNode->keyValues.insert(pair<int, int>(key, rid));            if (itr.second)            {                cout << "插入成功" << endl;            }            else            {                cout << "插入失败" << endl;                return false;            }            adjustAfterInsert(lNode, 1);            return true;        }    }

寻找插入点

Leaf_Node *findInsertPoint(int key)     {        Node *curNode = m_RootNode;        int depth = 1;        //根节点是叶子节点,直接返回这个节点, 实际开发可以用一个标识标识叶子节点  非叶子节点         if (typeid(*curNode) == typeid(Leaf_Node))        {            return static_cast<Leaf_Node *>(curNode);        }        //根节点是非叶子节点 找到那个叶子节点        while (depth <= m_Depth)        {            bool isLower = false;                auto nextLevelNodesItr = static_cast<None_Leaf_Node *>(curNode)->nextLevelNodes.begin();                for (const int &tempKey : static_cast<None_Leaf_Node *>(curNode)->keys)                {                    if (key < tempKey)                    {                        isLower = true;                        curNode = *nextLevelNodesItr;                        break;                    }                    nextLevelNodesItr++;                }                if (isLower == false)                {                    curNode = *nextLevelNodesItr;                }            depth++;        }        //处理叶子节点  depth == m_Depth        return static_cast<Leaf_Node *>(curNode);    }

插入后调整

void adjustAfterInsert(Node *node, uint32_t depth)    {        if (node->getNodeEntrySize() <= m_MaxEntryNum)        {            return;        }        if (depth > m_Depth)        {            m_Depth = depth;        }        //判断是非叶子节点还是叶子节点         if (typeid(*node) == typeid(None_Leaf_Node))        {            None_Leaf_Node *curNode = static_cast<None_Leaf_Node *>(node);            None_Leaf_Node *newNextNode = new None_Leaf_Node;            newNextNode->fatherNode = curNode->fatherNode;            //需要移动索引和子节点              auto childItr =  curNode->nextLevelNodes.begin();            advance(childItr, 1);            int count = 0;            list<Node *>::iterator delChildItr;            list<int>::iterator delKeyItr = curNode->keys.begin();            for (const auto &curKey : curNode->keys)            {                if (count > m_MinEntryNum)                {                    if (newNextNode->keys.empty())                    {                        delChildItr = childItr;                    }                    //加入到新节点                    newNextNode->keys.push_back(curKey);                    newNextNode->nextLevelNodes.push_back(*childItr);                }                else                {                    delKeyItr++;                }                count++;                childItr++;            }            //删除原来的              curNode->keys.erase(delKeyItr, curNode->keys.end());            curNode->nextLevelNodes.erase(delChildItr, curNode->nextLevelNodes.end());            //调整父节点  父节点为空  当前是根节点            if (curNode->fatherNode == nullptr)            {                None_Leaf_Node *newRootNode = new None_Leaf_Node;                newRootNode->pid = 1;                newRootNode->keys.push_back(*delKeyItr);                newRootNode->nextLevelNodes.push_back(curNode);                newRootNode->nextLevelNodes.push_back(newNextNode);                //修改根节点                m_RootNode = newRootNode;                return;            }            else              {                       auto itr = lower_bound(curNode->fatherNode->keys.begin(), curNode->fatherNode->keys.end(), *delKeyItr);                //需要保证key 和  子节点的一致性  用set方便                  curNode->fatherNode->keys.insert(itr, *delKeyItr);                auto itr2 = curNode->fatherNode->nextLevelNodes.begin();                for (; itr2 != curNode->fatherNode->nextLevelNodes.end(); itr2++)                {                    if (static_cast<Leaf_Node *>(*itr2)->keyValues.begin()->first == *delKeyItr)                    {                        itr2++;                        break;                    }                }                curNode->fatherNode->nextLevelNodes.insert(itr2, newNextNode);                adjustAfterInsert(curNode->fatherNode, ++depth);            }        }        else//叶子节点         {            Leaf_Node *curNode = static_cast<Leaf_Node *>(node);            Leaf_Node *nextLeafNode = new Leaf_Node();            None_Leaf_Node *fatherNode = curNode->fatherNode;            nextLeafNode->fatherNode = fatherNode;            nextLeafNode->nextLeafNode = curNode->nextLeafNode;            curNode->nextLeafNode = nextLeafNode;            //分裂叶子节点            int count = 1;            int insertKey;            for (const auto & itr : curNode->keyValues)            {                if (count > m_MinEntryNum)                {                           if (nextLeafNode->keyValues.empty())                    {                        insertKey = itr.first;                    }                    nextLeafNode->keyValues.insert(itr);                }                count++;            }            //删除原来的过半的  不可能有重复            auto eraseItr = curNode->keyValues.lower_bound(insertKey);            curNode->keyValues.erase(eraseItr, curNode->keyValues.end());            int toInsertKey = nextLeafNode->keyValues.begin()->first;            //修改父节点            if (fatherNode == nullptr)            {                None_Leaf_Node *newRootNode = new None_Leaf_Node;                newRootNode->keys.push_back(toInsertKey);                newRootNode->nextLevelNodes.push_back(curNode);                newRootNode->nextLevelNodes.push_back(nextLeafNode);                curNode->fatherNode = newRootNode;                nextLeafNode->fatherNode = newRootNode;                //修改根节点                m_RootNode = newRootNode;            }            else            {                //插入关键字和子节点                //先找到插入点                auto itr = lower_bound(fatherNode->keys.begin(), fatherNode->keys.end(), toInsertKey);                //需要保证key 和  子节点的一致性  用set方便                  fatherNode->keys.insert(itr, toInsertKey);                //插入子节点， 用set  重载node运算符 更方便一些                 auto itr2 = fatherNode->nextLevelNodes.begin();                for (;itr2 != fatherNode->nextLevelNodes.end(); itr2++)                {                    if (static_cast<Leaf_Node *>(*itr2)->keyValues.begin()->first == toInsertKey)                    {                        itr2++;                        break;                    }                }                fatherNode->nextLevelNodes.insert(itr2, nextLeafNode);                adjustAfterInsert(fatherNode, ++depth);            }                   }    }

Tips 简单实现和测试GitHub