📜  在B树中插入操作

📅  最后修改于: 2021-04-17 11:09:46             🧑  作者: Mango

在上一篇文章中,我们介绍了B-Tree。我们还讨论了search()和traverse()函数。
在这篇文章中,将讨论insert()操作。始终在叶节点处插入一个新密钥。让要插入的密钥为k。像BST一样,我们从根开始向下遍历,直到到达叶节点。到达叶节点后,将密钥插入该叶节点。与BST不同,我们在节点可以包含的键数上有一个预定义的范围。因此,在将密钥插入节点之前,我们确保节点具有额外的空间。
在插入密钥之前,如何确保节点有空间可用于密钥?我们使用一个称为splitChild()的操作,该操作用于拆分节点的子级。请参阅下图以了解拆分。在下图中,x的子y被分为两个节点y和z。请注意,splitChild操作将键向上移动,这就是B树长大的原因,与BST长大的原因不同。

B树分割

如上所述,要插入新密钥,我们需要从根到叶。在遍历到一个节点之前,我们首先检查该节点是否已满。如果节点已满,我们将其拆分以创建空间。以下是完整的算法。

插入
1)初始化x为根。
2)当x不是叶子时,请执行以下操作
.. a)找到接下来要遍历的x的子代。让孩子成为你。
.. b)如果y未满,则将x更改为指向y。
.. c)如果y已满,请将其拆分并更改x以指向y的两个部分之一。如果k小于y的中键,则将x设置为y的第一部分。 y的其他第二部分。拆分y时,会将键从y移到其父x。
3)当x是叶子时,步骤2中的循环停止。 x必须有空间容纳1个额外的键,因为我们已经预先拆分了所有节点。因此,只需将k插入x。

请注意,该算法遵循Cormen书。它实际上是一种主动插入算法,其中在下到节点之前,如果节点已满则将其拆分。之前进行拆分的好处是,我们永远不会遍历一个节点两次。如果我们在进入节点之前不分割节点,而仅在插入新键(反应性)时才分割节点,则最终可能会再次从叶到根遍历所有节点。在从根到叶的路径上的所有节点都已满的情况下,会发生这种情况。因此,当我们到达叶子节点时,我们将其拆分并向上移动关键点。向上移动键将导致父节点分裂(因为父节点已满)。这种级联效果永远不会在这种主动插入算法中发生。这种主动插入的缺点是,我们可能会进行不必要的拆分。

让我们用最小度为’t’的示例树为3并在初始为空的B树中的整数序列10、20、30、40、50、60、70、80和90理解算法。

最初的root是NULL。让我们首先插入10。
树1

现在让我们插入20、30、40和50。它们都将被插入根目录,因为节点可以容纳的最大键数是2 * t – 1,即5。

BTree2Ins

现在让我们插入60。由于根节点已满,因此它将首先拆分为两个,然后将60插入到适当的子节点中。
BTreeIns3

现在让我们插入70和80。这些新密钥将被插入到适当的叶子中,而不会进行任何拆分。
BTreeIns4

现在让我们插入90。此插入将导致拆分。中键将转到父级。
BTreeIns6

以下是上述主动算法的C++实现。

// C++ program for B-Tree insertion
#include
using namespace std;
  
// A BTree node
class BTreeNode
{
    int *keys;  // An array of keys
    int t;      // Minimum degree (defines the range for number of keys)
    BTreeNode **C; // An array of child pointers
    int n;     // Current number of keys
    bool leaf; // Is true when node is leaf. Otherwise false
public:
    BTreeNode(int _t, bool _leaf);   // Constructor
  
    // A utility function to insert a new key in the subtree rooted with
    // this node. The assumption is, the node must be non-full when this
    // function is called
    void insertNonFull(int k);
  
    // A utility function to split the child y of this node. i is index of y in
    // child array C[].  The Child y must be full when this function is called
    void splitChild(int i, BTreeNode *y);
  
    // A function to traverse all nodes in a subtree rooted with this node
    void traverse();
  
    // A function to search a key in the subtree rooted with this node.
    BTreeNode *search(int k);   // returns NULL if k is not present.
  
// Make BTree friend of this so that we can access private members of this
// class in BTree functions
friend class BTree;
};
  
// A BTree
class BTree
{
    BTreeNode *root; // Pointer to root node
    int t;  // Minimum degree
public:
    // Constructor (Initializes tree as empty)
    BTree(int _t)
    {  root = NULL;  t = _t; }
  
    // function to traverse the tree
    void traverse()
    {  if (root != NULL) root->traverse(); }
  
    // function to search a key in this tree
    BTreeNode* search(int k)
    {  return (root == NULL)? NULL : root->search(k); }
  
    // The main function that inserts a new key in this B-Tree
    void insert(int k);
};
  
// Constructor for BTreeNode class
BTreeNode::BTreeNode(int t1, bool leaf1)
{
    // Copy the given minimum degree and leaf property
    t = t1;
    leaf = leaf1;
  
    // Allocate memory for maximum number of possible keys
    // and child pointers
    keys = new int[2*t-1];
    C = new BTreeNode *[2*t];
  
    // Initialize the number of keys as 0
    n = 0;
}
  
// Function to traverse all nodes in a subtree rooted with this node
void BTreeNode::traverse()
{
    // There are n keys and n+1 children, traverse through n keys
    // and first n children
    int i;
    for (i = 0; i < n; i++)
    {
        // If this is not leaf, then before printing key[i],
        // traverse the subtree rooted with child C[i].
        if (leaf == false)
            C[i]->traverse();
        cout << " " << keys[i];
    }
  
    // Print the subtree rooted with last child
    if (leaf == false)
        C[i]->traverse();
}
  
// Function to search key k in subtree rooted with this node
BTreeNode *BTreeNode::search(int k)
{
    // Find the first key greater than or equal to k
    int i = 0;
    while (i < n && k > keys[i])
        i++;
  
    // If the found key is equal to k, return this node
    if (keys[i] == k)
        return this;
  
    // If key is not found here and this is a leaf node
    if (leaf == true)
        return NULL;
  
    // Go to the appropriate child
    return C[i]->search(k);
}
  
// The main function that inserts a new key in this B-Tree
void BTree::insert(int k)
{
    // If tree is empty
    if (root == NULL)
    {
        // Allocate memory for root
        root = new BTreeNode(t, true);
        root->keys[0] = k;  // Insert key
        root->n = 1;  // Update number of keys in root
    }
    else // If tree is not empty
    {
        // If root is full, then tree grows in height
        if (root->n == 2*t-1)
        {
            // Allocate memory for new root
            BTreeNode *s = new BTreeNode(t, false);
  
            // Make old root as child of new root
            s->C[0] = root;
  
            // Split the old root and move 1 key to the new root
            s->splitChild(0, root);
  
            // New root has two children now.  Decide which of the
            // two children is going to have new key
            int i = 0;
            if (s->keys[0] < k)
                i++;
            s->C[i]->insertNonFull(k);
  
            // Change root
            root = s;
        }
        else  // If root is not full, call insertNonFull for root
            root->insertNonFull(k);
    }
}
  
// A utility function to insert a new key in this node
// The assumption is, the node must be non-full when this
// function is called
void BTreeNode::insertNonFull(int k)
{
    // Initialize index as index of rightmost element
    int i = n-1;
  
    // If this is a leaf node
    if (leaf == true)
    {
        // The following loop does two things
        // a) Finds the location of new key to be inserted
        // b) Moves all greater keys to one place ahead
        while (i >= 0 && keys[i] > k)
        {
            keys[i+1] = keys[i];
            i--;
        }
  
        // Insert the new key at found location
        keys[i+1] = k;
        n = n+1;
    }
    else // If this node is not leaf
    {
        // Find the child which is going to have the new key
        while (i >= 0 && keys[i] > k)
            i--;
  
        // See if the found child is full
        if (C[i+1]->n == 2*t-1)
        {
            // If the child is full, then split it
            splitChild(i+1, C[i+1]);
  
            // After split, the middle key of C[i] goes up and
            // C[i] is splitted into two.  See which of the two
            // is going to have the new key
            if (keys[i+1] < k)
                i++;
        }
        C[i+1]->insertNonFull(k);
    }
}
  
// A utility function to split the child y of this node
// Note that y must be full when this function is called
void BTreeNode::splitChild(int i, BTreeNode *y)
{
    // Create a new node which is going to store (t-1) keys
    // of y
    BTreeNode *z = new BTreeNode(y->t, y->leaf);
    z->n = t - 1;
  
    // Copy the last (t-1) keys of y to z
    for (int j = 0; j < t-1; j++)
        z->keys[j] = y->keys[j+t];
  
    // Copy the last t children of y to z
    if (y->leaf == false)
    {
        for (int j = 0; j < t; j++)
            z->C[j] = y->C[j+t];
    }
  
    // Reduce the number of keys in y
    y->n = t - 1;
  
    // Since this node is going to have a new child,
    // create space of new child
    for (int j = n; j >= i+1; j--)
        C[j+1] = C[j];
  
    // Link the new child to this node
    C[i+1] = z;
  
    // A key of y will move to this node. Find the location of
    // new key and move all greater keys one space ahead
    for (int j = n-1; j >= i; j--)
        keys[j+1] = keys[j];
  
    // Copy the middle key of y to this node
    keys[i] = y->keys[t-1];
  
    // Increment count of keys in this node
    n = n + 1;
}
  
// Driver program to test above functions
int main()
{
    BTree t(3); // A B-Tree with minium degree 3
    t.insert(10);
    t.insert(20);
    t.insert(5);
    t.insert(6);
    t.insert(12);
    t.insert(30);
    t.insert(7);
    t.insert(17);
  
    cout << "Traversal of the constucted tree is ";
    t.traverse();
  
    int k = 6;
    (t.search(k) != NULL)? cout << "\nPresent" : cout << "\nNot Present";
  
    k = 15;
    (t.search(k) != NULL)? cout << "\nPresent" : cout << "\nNot Present";
  
    return 0;
}

输出:

Traversal of the constucted tree is  5 6 7 10 12 17 20 30
Present
Not Present

参考:
算法入门第三版,作者:Clifford Stein,Thomas H. Cormen,Charles E. Leiserson,Ronald L. Rivest
http://www.cs.utexas.edu/users/djimenez/utsa/cs3343/lecture17.html