数据结构：2-3树

声明：本文为学习 数据结构与算法分析(第三版) Clifford A.Shaffer 著 的学习笔记，代码有参考该书的示例代码。

2-3树

2-3 树的形状定义如下：

1. 一个结点包含一个或两个关键码。
2. 每个内部结点有两个子结点（如果它包含一个关键码）或者三个子结点（如果它包含两个关键码），它因此得名 2-3 树。
3. 所有叶结点都在树结构的同一层，因此树的高度总是平衡的。

2-3 树保持了类似于BST 的检索树的特征。
为了维持这些形状特征和检索特征，在结点插入、删除时需要采取特别的操作。2-3 树有这样一个优点，它能以相对较低的代价保持树高度的平衡。

一棵二叉树

2-3 树结点的实现

首先定义2-3树的结点：

template<typename Key, typename E>
class Tree_23Node
{
    protected:
    Key lkey, rkey;
    E lit, rit;

    public:

    static Key emptyKey;

    static void setEmptyKey(const Key& key)
    {
        emptyKey = key;
    }

    Tree_23Node() { lkey = rkey = emptyKey; }
    virtual ~Tree_23Node() {}
    virtual Key leftKey() const { return lkey; }
    virtual Key rightKey() const { return rkey; }
    virtual E leftValue() const { return lit; }
    virtual E rightValue() const { return rit; }
    virtual Tree_23Node* leftChild() const { return nullptr; }
    virtual Tree_23Node* rightChild() const { return nullptr; }
    virtual Tree_23Node* midChild() const { return nullptr; }
    virtual void setLeafChild( Tree_23Node* ) {}
    virtual void setMidChild( Tree_23Node* ) {}
    virtual void setRightChild( Tree_23Node* ) {}
    virtual void setLeft(const Key& k, const E& it = nullptr) { lkey = k, lit = it; }
    virtual void setRight(const Key& k, const E& it = nullptr) { rkey = k, rit = it; }
    //------------------------------------
    virtual Tree_23Node<Key, E>* add(Tree_23Node<Key, E>* root) = 0;
    virtual bool isLeaf() const = 0;
};
template<typename Key, typename E>
Key Tree_23Node<Key, E>::emptyKey = reinterpret_cast< Key >(0);

这里做的有点复杂了。但是因为叶子结点是没有孩子结点的指针的，所以再分别定义内部结点和叶子结点。

2-3 树结点的插入

在 2-3 树中，比较难的是，2-3 树的插入。
2-3 树的插入，有时候是需要叶结点的分裂。
2-3 树的插入是把记录插入到叶结点，然后再一层层提升。
首先应该是完成2-3 树的结点的插入，叶子结点的插入如下：

    Tree_23Node<Key, E>* add(Tree_23Node<Key, E>* root)
    {
        if(rkey == emptyKey)
        {
            if(root->leftKey() >= lkey)
            {
                rkey = root->leftKey(), rit = root->leftValue();
            }
            else
            {
                rkey = lkey, rit = lit;
                lkey = root->leftKey(), lit = root->leftValue();                
            }
            delete root;
            return this;
        }
        else if( root->leftKey() < lkey) //Add left
        {
            root->setMidChild(new LeafNode(rkey, rit));
            rkey = lkey, rit = lit;
            lkey = root->leftKey(), lit = root->leftValue();
            root->setLeft(rkey, rit);
            rkey = emptyKey;
            root->setLeafChild(this);
            return root;
        }
        else if( root->leftKey() < rkey) //Add center
        {
            root->setMidChild(new LeafNode(rkey, rit));
            root->setLeafChild(this);
            rkey = emptyKey;
            return root;
        }
        else //add right
        {
            root->setLeafChild(this);
            root->setMidChild(new LeafNode(root->leftKey(), root->leftValue() ));
            root->setLeft(rkey, rit);
            rkey = emptyKey;
            return root;
        }
    }

返回的是提升的结点。如果没有结点提升，则返回该结点的 this 指针。
内部结点的 add 差不多，只是要记得处理孩子指针的指向：

    Tree_23Node<Key, E>* add(Tree_23Node<Key, E>* root)
    {
        if(rkey == emptyKey )
        {
            if( root->leftKey() >= lkey)
            {
                rkey = root->leftKey(), rit = root->leftValue();
                mchild = root->leftChild(), rchild = root->midChild();
            }
            else
            {
                rkey = lkey, rit = lit;
                lkey = root->leftKey(), lit = root->leftValue();
                rchild = mchild;
                lchild = root->leftChild(), mchild = root->midChild(); 
            }
            delete root;
            return this;
        }
        else if(root->leftKey() < lkey) //add left
        {
            decltype(root) center = new IntalNode(lkey, lit, root, this);
            lkey = rkey, lit = rit;
            rkey = emptyKey;
            lchild = mchild, mchild = rchild, rchild = nullptr;
            return center;
        }
        else if(root->leftKey() < rkey)
        {
            //add center
            decltype(root) right = new IntalNode(rkey, rit, root->midChild(), rchild);
            rkey = emptyKey;
            mchild = root->leftChild();
            rchild = nullptr;
            root->setLeafChild(this), root->setMidChild(right);
            return root;
        }
        else
        {
            //add right
            decltype(root) center = new IntalNode(rkey, rit, this, root);
            rkey = emptyKey;
            rchild = nullptr;
            return center;
        }
    }

*在书中，结点的实现并没有分开叶子结点和内部结点，这里分开实现结点，所以add 的方法也要分别实现。（其实代码还是有点臃肿了）

2-3树的实现

结点的定义好了，那么树的实现也容易多了。
树依然继承字典的接口（具体看前面的博客）。
这里展示一下树的插入辅助函数

    Tree_23Node<Key, E>* insertHelp(Tree_23Node<Key, E>* root, const Key& k, const E& it)
    {
        if(root == nullptr )    return new LeafNode<Key, E>(k, it);

        if(root->isLeaf())
        {
            return root->add( new IntalNode<Key, E>(k, it));
        }
        else if(k < root->leftKey() )
        {
            auto temp = insertHelp(root->leftChild(), k, it);
            if(temp!=root->leftChild() )
                return root->add(temp);
            return root;
        }
        else if(root->rightKey()==root->emptyKey || k < root->rightKey() )
        {
            auto temp = insertHelp(root->midChild(), k, it);
            if(temp != root->midChild() )
                return root->add(temp);
            return root;
        }
        else 
        {
            auto temp =  insertHelp(root->rightChild(), k, it);
            if(temp != root->rightChild() )
                return root->add(temp);
            return root;
        }
    }

由于2-3树是树高平衡的，而且每一个内部结点至少有2个子结点，从而知道树的最大深度是 logn 。

//———————–我是分割线——————————
后来写2-3树的删除操作时，才发现，前面的代码写得实在是复杂了。但是，就这样先，博客也不改了。

2-3树的删除

为什么要把删除和插入分开呢？
因为书上是没有2-3树的删除的，笔者自己查阅资料学习的。
非常感谢这位博客的博主 2-3 树 （第四篇） - angGoGo world

内部结点的删除

2-3树的删除分为内部结点、叶子结点的删除。结点删除后会导致树的结构不平衡，不足以维持2-3树的基本形状，所以有时候还要修复树。
先看看内部结点的删除。
回忆一下堆的删除，寻找inorder successor，在叶结点中找一个结点替代要删除的值，然后再删除叶结点。
这里同理，也就是说，还是先找一个值和内部结点替换，然后再删除叶子结点。
如下：

             53
          /       \
        34        60
       /  \       / \
      2   48，50  56  70

删除34的话，那么就把48放到34 的位置，然后删除48。
所以结果是：

             53
          /       \
        48        60
       /  \       / \
      2   50     56  70

如果<48，50>结点中只有<48> 的话，那么树就会变得不平衡，需要修复，这里为了讨论方便，暂时不讨论复杂的情况

叶子结点的删除

叶子结点的删除很容易，只要把值删掉就可以了，然后需要注意的细节就是删除左键值对时，记得用右键值对填在左键值对上

             53
          /       \
        34        60
       /  \       / \
      2   48，50  56  70

这颗树删除掉48 ，则变为：

             53
          /       \
        34        60
       /  \       / \
      2   50     56  70

树的修复

假如有树：

             53
          /       \
        34        60
       /  \       / \
     2,18 50     56  70

如果上面那棵树再删除50的话，树就变为：

             53
          /       \
        34        60
       /  \       / \
   2,18    <>     56  70

有一个结点为空，这不符合2-3树的特征，那么就需要进行修复。
修复的步骤如下 ：

1. 看兄弟结点是否有值可借，如果有则把父结点中合适的值拉下来，从兄弟结点中借一个值作为父结点的值
2. 如果没有值可借，那么就把父结点拉下来合并
3. 回到 1 步骤，处理父结点，知道树的形状符合2-3树

有点难理解，看例子。

向兄弟借值

以上为例，把34拉下到右子树的位置，然后把18的值推上去。
那么修复后，树应该是：

             53
          /       \
        18        60
       /  \       / \
      2   34     56  70

同理，当结点左右关键值时，处理也是一样的：

                          53,78
                        /   |   \
                    10,20   60   98

删除60时，结果是：

                          20,78
                        /   |   \
                      10    53   98

合并父结点

以下面这棵树为例，当删除34结点时

             53
          /       \
        18        60
       /  \       / \
      2   34     56  70

变为：

             53
          /       \
        18        60
       /  \       / \
      2   <>     56  70

由于兄弟结点没有值可以借，那么就需要合并父结点：

             53
          /       \
        <>        60
       /  \       / \
    2,18   <>     56  70

此时处理《2，18》的父结点。按照顺序，没有兄弟结点可借，那么继续合并父结点：

         53,60
       /   |   \
    2,18  56   70

此时树的形状就符合2-3树的特征了。
注意在合并父结点的时候，记得处理孩子结点。如上，当合并 53，60时，应该合并把53 的左子树的孩子赋给53的左子树。

删除的代码如下：

    virtual Tree_23Node* deleteKey(const Key& k)
    {
        if(lkey !=k && rkey != k)
            return nullptr;
        if(isLeaf())//if is LeafNode
        {
            if(lkey == k)
            {
                rightToLeft();
            }
            rkey = emptyKey;
            return this;
        }
        else
        {
            //if is IntalNode
            Tree_23Node* temp = nullptr;
            if( lkey == k)
            {
                temp = findMin(midChild());
                lkey = temp->leftKey();
                lit = temp->leftValue();
            }
            else 
            {
                temp = findMin(rightChild());
                rkey = temp->leftKey();
                rit = temp->leftValue();
            }

            return temp->deleteKey(temp->leftKey());
        }
    }

修复树的代码如下：

    virtual void fixed(Tree_23Node* parent)
    {
        if(parent == nullptr)
            return;

        else if(parent->leftChild() == this)
        {
            auto mid = parent->midChild();
            //midChild borrow to leftChild
            if(mid->rightKey() == emptyKey)
            {
                //合并上下结点
                mid->setRight(mid->leftKey(), mid->leftValue());
                mid->setRightChild( mid->midChild() );
                mid->setMidChild( mid->leftChild() );
                mid->setLeft(parent->leftKey(), parent->leftValue() );
                if(leftChild() != nullptr)
                {
                    mid->setLeftChild( leftChild() );
                }
                else
                    mid->setLeftChild( midChild() );

                delete parent->leftChild();
                parent->rightToLeft();
            }
            else
            {
                //代替
                setLeft(parent->leftKey(), parent->leftValue());
                if(midChild() != nullptr)
                    setLeftChild(midChild());
                setMidChild(mid->leftChild());
                parent->setLeft(mid->leftKey(), mid->leftValue());
                mid->rightToLeft();
            }
            return;
        }
        else if(parent->midChild() == this)
        {
            //先向左借
            if(parent->leftChild()->rightKey() != emptyKey)
            {
                auto left = parent->leftChild();
                setLeft(parent->leftKey(), parent->leftValue());
                if(leftChild() != nullptr)
                    setMidChild(leftChild());
                setLeftChild(left->rightChild());
                parent->setLeft(left->rightKey(), left->rightValue());
                left->setRight(emptyKey, left->rightValue());
                left->setRightChild(nullptr);
            }
            else if(parent->rightChild()!=nullptr && parent->rightChild()->rightKey() != emptyKey)
            {
                //向右借
                auto right = parent->rightChild();
                setLeft(parent->rightKey(), parent->rightValue());
                if(midChild() != nullptr)
                    setLeftChild(midChild());
                setMidChild(right->leftChild());
                parent->setRight(right->leftKey(), right->leftValue());
                right->rightToLeft();
            }
            else 
            {
                //合并、向左边合并
                auto left = parent->leftChild();
                left->setRight(parent->leftKey(), parent->leftValue() );
                if(leftChild() != nullptr)
                    left->setRightChild( leftChild() );
                else 
                    left->setRightChild( midChild() );
                delete parent->midChild();
                parent->setMidChild( parent->rightChild() );
                parent->setLeft( parent->rightKey(), parent->rightValue() );
                parent->setRight(emptyKey, parent->rightValue() );
                parent->setRightChild(nullptr);
            }
        }
        else if(parent->rightChild() == this)
        {
            auto mid = parent->midChild();
            if(mid->rightKey() == emptyKey)
            {
                //合并
                mid->setRight(parent->rightKey(), parent->rightValue() );
                if( leftChild() != nullptr )
                    mid->setRightChild(  leftChild() );
                else
                    mid->setRightChild(  midChild() );
                parent->setRight(emptyKey, parent->rightValue());
                delete parent->rightChild();
                parent->setRightChild(nullptr);
            }
            else
            {
                //借结点
                setLeft(parent->rightKey(), parent->rightValue());
                if(leftChild() != nullptr)
                    setMidChild(leftChild());
                setLeftChild(mid->rightChild());
                parent->setRight(mid->rightKey(), mid->rightValue());
                mid->setRight(emptyKey, mid->rightValue());
                mid->setRightChild(nullptr);
            }
            return ;
        }
    }

当然，如果延续本文的写法，那么在修复树的时候，需要额外的查找来找到当前结点的父结点。
一个比较好的方法是，在结点中保存父结点的指针。这是用空间换时间的一个好方法。

其他代码可以在github上找到：
xiaosa233

–END–