《算法导论》18.3 从B树中删除关键字（含有C++代码）

一、基本操作

二、C++代码

#include <iostream>
using namespace std;
static const int m = 3;  //定义最小度为3
static const int key_max = 2 * m - 1;//关键字最大个数
static const int key_min = m - 1;//关键字最小个数
static const int child_max = key_max + 1;//子节点最大个数(这里可以看出子节点数与关键字数有关)
static const int child_min = key_min + 1;//子节点最小个数

template <class T>
class BTree;//前置声明
/*
类名:BTnode
*/
template <class T>
class BTnode
{
    friend class BTree<T>;//友元函数
public:
    BTnode()
    {
        keyNum = 0;
        parent = NULL;//父节点初始化
        isleaf = true;
        int i;
        for (i = 0; i < child_max; i++)//子树指针数组初始化
        {
            pchild[i] = NULL;
        }
        for (i = 0; i < key_max; i++)//关键字数组初始化
        {
            keyvalue[i] = '\0';
        }
    }
private:
    bool isleaf;//判断节点是否是叶子节点
    int keyNum;//关键字个数
    BTnode<T>* parent;//指向父节点
    BTnode<T>* pchild[child_max];//子树指针数组
    T   keyvalue[key_max];//关键字数组
};

/*
类名:BTree
*/
template <class T>
class BTree
{
public:
    /*
   函数名:BTree
   函数作用:无参构造函数
   函数参数:无
   函数返回值: 无
   */

    BTree()
    {
        root = NULL;
    }

    //打印元素
    void printpoint(BTnode<T>* node, int count)
    {
        if (node != NULL)//判断元素是否为空
        {
            int i, j;
            //每个节点从小到大打印
            for (i = 0; i < node->keyNum; i++)
            {
                //判断是否叶节点,不是的话则要往子节点中寻找打印
                if (!node->isleaf)//判断是否是叶子节点
                {
                    printpoint(node->pchild[i], count - 3);
                }
                for (j = count; j >= 0; j--)
                {
                    cout << "-";
                }
                cout << "|" << node->keyvalue[i] << "|" << endl;
            }
            if (!node->isleaf)//子节点数比关键字数多一个
            {
                printpoint(node->pchild[i], count - 3);
            }
        }
    }

    //printpoint无参函数传递值过去
    void printpoint()
    {
        printpoint(root, key_max * 5);
    }
    
    //删除
    bool BTree_delete(T value)
    {
        if (!contain(value))
        {
            return false;
        }
        if (root->keyNum == 1)
        {
            if (root->isleaf)
            {
                delete root;
                root = NULL;
                return true;
            }
            else//当根节点只有一个关键字时且不为叶子节点
            {
                BTnode<T>* node_child1 = root->pchild[0];
                BTnode<T>* node_child2 = root->pchild[1];
                //减少一层树的高度
                if (node_child1->keyNum == key_min && node_child2->keyNum == key_min)
                {
                    MergeBlock(root, 0);
                    delete root;
                    root = node_child1;
                }
            }
        }
        BTree_deletebalance(root, value);
    }

    //合并块
    void MergeBlock(BTnode<T>* node_parent, int child_index)
    {
        BTnode<T>* node_child1 = node_parent->pchild[child_index];
        BTnode<T>* node_child2 = node_parent->pchild[child_index + 1];
        //将父节点的节点对应的关键字下移
        node_child1->keyvalue[key_min] = node_parent->keyvalue[child_index];
        node_child1->keyNum = key_max;
        int i;
        for (i = 0; i < key_min; i++)
        {
            node_child1->keyvalue[child_min + i] = node_child2->keyvalue[i];
        }
        //判断node_child1是否是叶子节点,不是叶子节点则要将node_child2的子节点赋值给node_child1
        if (!node_child1->isleaf)
        {
            for (i = 0; i < child_min; i++)
            {
                node_child1->pchild[i + child_min] = node_child2->pchild[i];
            }
        }
        //因为父节点下移一个关键字,则关键字后的所有值要往前移动一个
        node_parent->keyNum--;
        for (i = child_index; i < node_parent->keyNum; i++)
        {
            node_parent->keyvalue[i] = node_parent->keyvalue[i + 1];
            //子节点也要往前移动一位
            node_parent->pchild[i + 1] = node_parent->pchild[i + 2];
        }
        delete node_child2;
        node_child2 = NULL;
    }

    //在左边的兄弟节点中找一个最大的
    T getprev(BTnode<T>* node)
    {
        //在比节点位置小的节点中找一个最大的值最为
        while (!node->isleaf)
        {
            node = node->pchild[node->keyNum];
        }
        node->keyNum--;
        return node->keyvalue[node->keyNum - 1];
    }

    //在右边的兄弟节点中找一个最小的
    T getnext(BTnode<T>* node)
    {
        //在比节点位置大的节点中找一个最小的
        while (!node->isleaf)
        {
            node = node->pchild[0];
        }
        return node->keyvalue[0];
    }

    //用递归删除并做修复
    void BTree_deletebalance(BTnode<T>* node, T value)
    {
        int i;
        //在当前节点中找合适坐标使得value在这个区间内
        for (i = 0; i < node->keyNum && value > node->keyvalue[i]; i++)
        {

        }
        //如果当前i的关键字等于value
        if (i < node->keyNum && value == node->keyvalue[i])
        {
            //判断当前节点是否是叶子节点,如果是的话直接删除,下面的情况保证了如果value在叶子节点的话,叶子节点keyNum一定是>=child_min
            if (node->isleaf)
            {
                node->keyNum--;
                //把i后面的都往前移动一位
                for (; i < node->keyNum; i++)
                {
                    node->keyvalue[i] = node->keyvalue[i + 1];
                }
                return;
            }
            else//当前节点为内节点
            {
                //里面关键字都比value小的节点
                BTnode<T>* node_left = node->pchild[i];
                //里面关键字都比value大的节点
                BTnode<T>* node_right = node->pchild[i + 1];
                if (node_left->keyNum >= child_min)//左子节点中的关键字数大于等于child_min
                {
                    T prev_replace = getprev(node_left);
                    //传递不平衡点让pre_replace
                    BTree_deletebalance(node_left, prev_replace);
                    //让前继的关键字替换当前删除的关键字
                    node->keyvalue[i] = prev_replace;
                    return;
                }
                else if (node_right->keyNum >= child_min)//右子节点中的关键字数大于等于child_min
                {
                    T next_replace = getnext(node_right);
                    //在左边中找到最大的那个递归替换
                    BTree_deletebalance(node_right, next_replace);
                    //让前继的关键字替换当前删除的关键字
                    node->keyvalue[i] = next_replace;
                    return;
                }
                else//左右子节点中的关键字数都等于key_min
                {
                    //合并两个子节点
                    MergeBlock(node, i);
                    //在合并的节点中删除value值
                    BTree_deletebalance(node_left, value);
                }
            }
        }
        else//关键字不在当前节点(下面步骤保证了遍历的所有节点关键字数都是大于等于child_min)
        {
            //在(<<value<<)的区间找
            BTnode<T>* node_child = node->pchild[i];//这里i = node->keyNum
            BTnode<T>* node_left = NULL;
            BTnode<T>* node_right = NULL;
            if (node_child->keyNum == key_min)//当前节点只有两个关键字,补给当前节点使之大于等于child_min
            {
                //判断是否有左右兄弟节点
                if (i > 0)
                {
                    node_left = node->pchild[i - 1];
                }
                if (i <= node->keyNum - 1)
                {
                    node_right = node->pchild[i + 1];
                }
                int j;
                //当前左兄弟的关键字数大于等于child_min
                if (node_left && node_left->keyNum >= child_min)
                {
                    //把父节点的i-1对应的关键字下移
                    for (j = node_child->keyNum; j > 0; j--)
                    {
                        node_child->keyvalue[j] = node_child->keyvalue[j - 1];
                    }
                    node_child->keyvalue[0] = node->keyvalue[i - 1];
                    //如果子节点的左兄弟节点不是叶子节点
                    if (!node_left->isleaf)
                    {
                        //把左兄弟最右边的子节点指针赋值给node_child
                        for (j = node_child->keyNum + 1; j > 0; j--)
                        {
                            node_child->pchild[j - 1]->parent = node_child->pchild[j]->parent;
                            node_child->pchild[j] = node_child->pchild[j - 1];

                        }
                        node_left->pchild[node_left->keyNum]->parent = node_child->pchild[0];
                        node_child->pchild[0] = node_left->pchild[node_left->keyNum];
                    }
                    node_child->keyNum++;
                    node->keyvalue[i - 1] = node_left->keyvalue[node_left->keyNum - 1];
                    node_left->keyNum--;
                }
                else if (node_right && node_right->keyNum >= child_min)
                {
                    //把父节点的i对应的关键字下移
                    node_child->keyvalue[node_child->keyNum] = node->keyvalue[i];
                    node_child->keyNum++;
                    //把右兄弟节点最小的关键字赋值给父节点的i位置
                    node->keyvalue[i] = node_right->keyvalue[0];
                    node_right->keyNum--;
                    //把右兄弟的关键字往前移动一位
                    for (j = 0; j < node_right->keyNum; j++)
                    {
                        node_right->keyvalue[j] = node_right->keyvalue[j + 1];
                    }
                    //如果右兄弟不是叶子节点则需要把右兄弟最左边的子节点指针赋值给node_child
                    if (!node_right->isleaf)
                    {
                        node_right->pchild[0]->parent = node_child->pchild[node_child->keyNum]->parent;
                        node_child->pchild[node_child->keyNum] = node_right->pchild[0];
                        for (j = 0; j < node_right->keyNum + 1; j++)
                        {
                            node_right->pchild[j + 1]->parent = node_right->pchild[j]->parent;
                            node_right->pchild[j] = node_right->pchild[j + 1];

                        }

                    }
                }
                else if (node_left)//node_left只有child_min-1个关键字
                {
                    //把左兄弟合并
                    MergeBlock(node, i - 1);
                    //更新子节点
                    node_child = node_left;
                }
                else if (node_right)
                {
                    //把右兄弟合并,子节点无需更新
                    MergeBlock(node, i);
                }
            }
            BTree_deletebalance(node_child, value);
        }
    }
private:
    BTnode<T>* root;//根节点
};