B+树实现

最新推荐文章于 2024-05-02 07:35:58 发布

天之道，利而不害

最新推荐文章于 2024-05-02 07:35:58 发布

阅读量818

点赞数

分类专栏：数据结构文章标签：数据结构

本文链接：https://blog.csdn.net/oooooorz/article/details/112297554

版权

数据结构专栏收录该内容

2 篇文章 0 订阅

订阅专栏

B+树实现

https://github.com/cquzg/data_structrue

节点特征

典型的B+树节点如图所示，有 $n - 1$ 个键值， $n$ 个指针，且如果 $i < j$ ，有 $K_i < K_j$ 。

在这里插入图片描述

B+树中的节点分为两类：内部节点和叶子节点，区别在于叶子节点的指针指向实际存在的记录，且 $P_n$ 指向相邻的叶子节点，既叶子节点组成了一个单链表。显然，单链表方便了记录的顺序查找。

具体实现：

class node {
    private:
    int cnt, key[MAX];
    NODE_TYPE m_type;
    
    public:
    node();
    virtual ~node();
    
    void Error(int lind);
    
    int Size();
    
    int cnt_increase();
    
    int cnt_decrease();
    
    void set_key(int id, int x);
    
    int get_key(int id);
    
    void set_type(NODE_TYPE te);
    
    NODE_TYPE Type();
    
    int pos(int k);          // 查找第一个大于或等于 K 的位置
    
    int get_middle_key();    // 节点分裂的时候需要将中间位置的键值向上插到父节点中
};

class Internal_node: public node {
    private:
    node* pointer[MAX];
    
    public:
    Internal_node();
    ~Internal_node();
    
    void set_pointer(int id, node* p);
    
    node* get_pointer(int id);
    
    /*
    假设 k 插入的位置是 i
    p 插入的位置是j
    一定满足：j = i + 1
    */
    void Insert(int k, node* p);
    
    Internal_node* split();
    
    void Merge(Internal_node* brother_node, int x);
    
    void Delete(int pos);
    
    void right_shift_one_position();
    
    void left_shift_one_position();
    
    void borrow_from_left_brother(Internal_node* left_brother, int x);
    
    void borrow_from_right_brother(Internal_node* right_brother, int x);
};

class Leaf_node: public node{
   	private:
    int value[MAX];
    Leaf_node* next;
    
    public:
    Leaf_node();
    ~Leaf_node();
    
    void set_value(int id, int x);
    
    int get_value(int id);
    
    void set_next(Leaf_node* np);
    
    Leaf_node* get_next();
    
    void Insert(int k, int va);
    
    Leaf_node* Split();
    
    void Merge(Leaf_node* brother_node);
    
    void Delete(int pos);
    
    void right_shift_one_position();
    
    void left_shift_one_position();
    
    void borrow_from_left_brother(Leaf_node* left_brother);
    
    void borrow_from_right_brother(Leaf_node* right_brother);
}

插入功能

根据B+树的定义，叶子节点的指针才指向实际存储的记录。插入一个键值对，需要先遍历到对应的叶子节点。如果该叶子节点已经满了，插入键值后，叶子节点分裂为两个节点。如果该叶子节点没满，插入键值后返回。显然，这个过程是递归的，叶子节点分裂可能会导致它的父节点分裂（因为上传了一个键值），父节点分裂可能会导致父节点的父节点分裂，直到分裂到根节点。

具体实现：每个节点遵守相同的顺序，先插入键值，再分裂。

笔者的写法是：当前节点插入键值，递归到其父节点时才判断当前节点是否过满。过满则分裂当前节点。显然，这样写需要单独判断根节点是否过满。

void Bplus_tree:: m_insert(node* cur, int k, int v) {
    if (cur->Type() == LEAF) {
        ((Leaf_node*)cur)->Insert(k, v);
        return;
    }
    else {
        int pos = cur->Pos(k);
        node* next_pointer = ((Internal_node*)cur)->get_pointer(pos);
        m_insert(next_pointer, k, v);
        
        if (next_pointer->Size() > MAX_KEY_NUMBER) {
            int up_key = next_pointer->get_middle_key();
            node* new_node = nullptr;
            if (next_pointer->Type() == LEAF) {
                new_node = ((Leaf_node*)next_pointer)->Split();

                ((Leaf_node*)new_node)->set_next(((Leaf_node*)next_pointer)->get_next());
                ((Leaf_node*)next_pointer)->set_next(((Leaf_node*)new_node));
            }
            else {
                node* new_node = ((Internal_node*)next_pointer)->Split(); 
            }
            ((Internal_node*)cur)->Insert(up_key, new_node);
        }
    }
}

删除功能

同样，删除一个键值对也需要遍历到叶子节点。删除该键值对后，如果叶子节点非半满，则向左兄弟或者右兄弟借一个键值，如果借不到，则与左兄弟或者右兄弟合并，并下拉父节点中对应的键值（叶子节点的合并不需要下拉键值）。如果能借到，则调整键值和指针（叶子节点和内部节点的调整过程不同）。显然这个过程也是递归的，节点的合并可能会导致根节点的消失。

在这里插入图片描述

如果删除的键值在内部节点（非叶子节点）出现过，则删除过程稍微复杂一点。记删除的键值为 $K$ ，含有 $K$ 的内部节点为 $u$ ， $K$ 在节点 $u$ 中的下标为 $i$ ，则 $P_{i + 1}$ 指向的节点为 $v$ 。记以 $v$ 为根的子树中的最小键值为 $v_{min}$ 。当递归回到 $u$ 节点时，先用 $v_{min}$ 替换掉 $K$ ，再执行原来的删除过程。

void Bplus_tree:: m_delete(node* cur, int k, int v) {
    if (cur->Type() == LEAF) {
        int pos = cur->Pos(k);
        if (((Leaf_node*)cur)->get_value(pos) == v) {
            ((Leaf_node*)cur)->Delete(pos);
            return;
        }
    }
    else {
        int pos = cur->Pos(k), flag = 0, replace_key = -2;
        if (cur->get_key(pos) == k) flag = 1;

        node* next_pointer = ((Internal_node*)cur)->get_pointer(pos + flag);
        m_delete(next_pointer, k, v);

        if (next_pointer->Size() * 2 < MAX_KEY_NUMBER) {
            node* left_brother = ((pos + flag) == 0 ? nullptr : ((Internal_node*)cur)->get_pointer(pos + flag - 1));
            node* right_brother = ((pos + flag) == cur->Size() ? nullptr : ((Internal_node*)cur)->get_pointer(pos + flag + 1));

            if (left_brother->Size() * 2 > MAX_KEY_NUMBER) {
                int n = left_brother->Size();
                int down_key = cur->get_key(pos + flag - 1);

                cur->set_key(pos + flag - 1, left_brother->get_key(n - 1));

                /* 
                首先判断节点类型，不同节点类型执行的操作稍微不同
                然后判断要删除的键是不是在内部节点出现过
                */
                if (left_brother->Type() == LEAF) {
                    ((Leaf_node*)next_pointer)->borrow_from_left_brother(((Leaf_node*)left_brother));
                }
                else {
                    if (flag) {
                        replace_key = m_find_replaceOfkey(cur, k);

                        if (replace_key == -1) cur->Error(__LINE__);
                        
                        ((Internal_node*)next_pointer)->borrow_from_left_brother(((Internal_node*)left_brother), replace_key);
                    }
                    else {
                        ((Internal_node*)next_pointer)->borrow_from_left_brother(((Internal_node*)left_brother), down_key);
                    }
                }
            }
            else if (right_brother->Size() * 2 > MAX_KEY_NUMBER) {
                int down_key = cur->get_key(pos + flag);

                if (right_brother->Type() == LEAF) {

                    cur->set_key(pos + flag, right_brother->get_key(1));
                    ((Leaf_node*)next_pointer)->borrow_from_right_brother(((Leaf_node*)right_brother));
                    
                    if (flag) {
                        cur->set_key(pos, next_pointer->get_key(0));
                    }
                }
                else {
                    if (flag) {
                        replace_key = m_find_replaceOfkey(cur, k);

                        if (replace_key == -1) cur->Error(__LINE__);

                        cur->set_key(pos + flag, right_brother->get_key(0));
                        ((Internal_node*)next_pointer)->borrow_from_right_brother(((Internal_node*)right_brother), down_key);

                        cur->set_key(pos, replace_key);
                    }
                    else {
                        cur->set_key(pos, right_brother->get_key(0));
                        ((Internal_node*)next_pointer)->borrow_from_right_brother(((Internal_node*)right_brother), down_key);
                    }
                }
            }
            else if (left_brother != nullptr) {
                if (left_brother->Type() == LEAF) {
                    ((Leaf_node*)left_brother)->set_next(((Leaf_node*)next_pointer)->get_next());
                    ((Leaf_node*)left_brother)->Merge(((Leaf_node*)next_pointer)); 
                }
                else {
                    if (flag) {
                        replace_key = m_find_replaceOfkey(cur, k);
                        ((Internal_node*)left_brother)->Merge(((Internal_node*)next_pointer), replace_key);
                    }
                    else {
                        int down_key = cur->get_key(pos - 1);
                        ((Internal_node*)left_brother)->Merge(((Internal_node*)next_pointer), down_key);
                    }
                }
                ((Internal_node*)cur)->Delete(pos + flag - 1);
            }
            else if (right_brother != nullptr) {
                if (next_pointer->Type() == LEAF) {
                    ((Leaf_node*)next_pointer)->set_next(((Leaf_node*)right_brother)->get_next());
                    ((Leaf_node*)next_pointer)->Merge(((Leaf_node*)right_brother));
                }
                else {
                    if (flag) {
                        replace_key = m_find_replaceOfkey(cur, k);
                        ((Internal_node*)next_pointer)->Merge(((Internal_node*)right_brother), replace_key);
                    }
                    else {
                        int down_key = cur->get_key(pos);
                        ((Internal_node*)next_pointer)->Merge(((Internal_node*)right_brother), down_key);
                    }
                }
                ((Internal_node*)cur)->Delete(pos);
            }
            else {
                cur->Error(__LINE__);
                return;
            }
        }
        else {
            if (flag) {
                replace_key = m_find_replaceOfkey(cur, k);
                cur->set_key(pos, replace_key);
            }
        }

    }
}