// C++ implemntation of search() and traverse() methods

#include<iostream>

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 function to traverse all nodes in a subtree rooted with this node

    void traverse();

 

    // A function to search a key in 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); }

};

 

// Constructor for BTreeNode class

BTreeNode::BTreeNode(int _t, bool _leaf)

{

    // Copy the given minimum degree and leaf property

    t = _t;

    leaf = _leaf;

 

    // Allocate memory for maximum number of possible keys

    // and child pointers

    keys = new int[*t-];

    C = new BTreeNode *[*t];

 

    // Initialize the number of keys as 0

    n = ;

}

// Function to traverse all nodes in a subtree rooted with this node

void BTreeNode::traverse()

{

    // There are n keys and n+1 children, travers through n keys

    // and first n children

    int i;

    for (i = ; 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 = ;

    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);

}

// C++ program for B-Tree insertion

#include<iostream>

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 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[*t-];

    C = new BTreeNode *[*t];

 

    // Initialize the number of keys as 0

    n = ;

}

 

// Function to traverse all nodes in a subtree rooted with this node

void BTreeNode::traverse()

{

    // There are n keys and n+1 children, travers through n keys

    // and first n children

    int i;

    for (i = ; 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 = ;

    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[] = k;  // Insert key

        root->n = ;  // Update number of keys in root

    }

    else // If tree is not empty

    {

        // If root is full, then tree grows in height

        if (root->n == *t-)

        {

            // Allocate memory for new root

            BTreeNode *s = new BTreeNode(t, false);

 

            // Make old root as child of new root

            s->C[] = root;

 

            // Split the old root and move 1 key to the new root

            s->splitChild(, root);

 

            // New root has two children now.  Decide which of the

            // two children is going to have new key

            int i = ;

            if (s->keys[] < 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-;

 

    // 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 >=  && keys[i] > k)

        {

            keys[i+] = keys[i];

            i--;

        }

 

        // Insert the new key at found location

        keys[i+] = k;

        n = n+;

    }

    else // If this node is not leaf

    {

        // Find the child which is going to have the new key

        while (i >=  && keys[i] > k)

            i--;

 

        // See if the found child is full

        if (C[i+]->n == *t-)

        {

            // If the child is full, then split it

            splitChild(i+, C[i+]);

 

            // 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+] < k)

                i++;

        }

        C[i+]->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 - ;

 

    // Copy the last (t-1) keys of y to z

    for (int j = ; j < t-; j++)

        z->keys[j] = y->keys[j+t];

 

    // Copy the last t children of y to z

    if (y->leaf == false)

    {

        for (int j = ; j < t; j++)

            z->C[j] = y->C[j+t];

    }

 

    // Reduce the number of keys in y

    y->n = t - ;

 

    // Since this node is going to have a new child,

    // create space of new child

    for (int j = n; j >= i+; j--)

        C[j+] = C[j];

 

    // Link the new child to this node

    C[i+] = z;

 

    // A key of y will move to this node. Find location of

    // new key and move all greater keys one space ahead

    for (int j = n-; j >= i; j--)

        keys[j+] = keys[j];

 

    // Copy the middle key of y to this node

    keys[i] = y->keys[t-];

 

    // Increment count of keys in this node

    n = n + ;

}

 

// Driver program to test above functions

int main()

{

    BTree t(); // A B-Tree with minium degree 3

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

 

    cout << "Traversal of the constucted tree is ";

    t.traverse();

 

    int k = ;

    (t.search(k) != NULL)? cout << "\nPresent" : cout << "\nNot Present";

 

    k = ;

    (t.search(k) != NULL)? cout << "\nPresent" : cout << "\nNot Present";

 

    return ;

}

Traversal of the constucted tree is

Present

Not Present

/* The following program performs deletion on a B-Tree. It contains functions

   specific for deletion along with all the other functions provided in the

   previous articles on B-Trees. See http://www.geeksforgeeks.org/b-tree-set-1-introduction-2/

   for previous article.

 

   The deletion function has been compartmentalized into 8 functions for ease

   of understanding and clarity

 

   The following functions are exclusive for deletion

   In class BTreeNode:

    1) remove

    2) removeFromLeaf

    3) removeFromNonLeaf

    4) getPred

    5) getSucc

    6) borrowFromPrev

    7) borrowFromNext

    8) merge

    9) findKey

 

   In class BTree:

     1) remove

 

  The removal of a key from a B-Tree is a fairly complicated process. The program handles

  all the 6 different cases that might arise while removing a key.

 

  Testing: The code has been tested using the B-Tree provided in the CLRS book( included

  in the main function ) along with other cases.

 

  Reference: CLRS3 - Chapter 18 - (499-502)

  It is advised to read the material in CLRS before taking a look at the code. */

 

#include<iostream>

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 function to traverse all nodes in a subtree rooted with this node

    void traverse();

 

    // A function to search a key in subtree rooted with this node.

    BTreeNode *search(int k);   // returns NULL if k is not present.

 

    // A function that returns the index of the first key that is greater

    // or equal to k

    int findKey(int k);

 

    // 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 wrapper function to remove the key k in subtree rooted with

    // this node.

    void remove(int k);

 

    // A function to remove the key present in idx-th position in

    // this node which is a leaf

    void removeFromLeaf(int idx);

 

    // A function to remove the key present in idx-th position in

    // this node which is a non-leaf node

    void removeFromNonLeaf(int idx);

 

    // A function to get the predecessor of the key- where the key

    // is present in the idx-th position in the node

    int getPred(int idx);

 

    // A function to get the successor of the key- where the key

    // is present in the idx-th position in the node

    int getSucc(int idx);

 

    // A function to fill up the child node present in the idx-th

    // position in the C[] array if that child has less than t-1 keys

    void fill(int idx);

 

    // A function to borrow a key from the C[idx-1]-th node and place

    // it in C[idx]th node

    void borrowFromPrev(int idx);

 

    // A function to borrow a key from the C[idx+1]-th node and place it

    // in C[idx]th node

    void borrowFromNext(int idx);

 

    // A function to merge idx-th child of the node with (idx+1)th child of

    // the node

    void merge(int idx);

 

    // Make BTree friend of this so that we can access private members of

    // this class in BTree functions

    friend class 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;

    }

 

    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);

 

    // The main function that removes a new key in thie B-Tree

    void remove(int k);

 

};

 

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[*t-];

    C = new BTreeNode *[*t];

 

    // Initialize the number of keys as 0

    n = ;

}

 

// A utility function that returns the index of the first key that is

// greater than or equal to k

int BTreeNode::findKey(int k)

{

    int idx=;

    while (idx<n && keys[idx] < k)

        ++idx;

    return idx;

}

 

// A function to remove the key k from the sub-tree rooted with this node

void BTreeNode::remove(int k)

{

    int idx = findKey(k);

 

    // The key to be removed is present in this node

    if (idx < n && keys[idx] == k)

    {

 

        // If the node is a leaf node - removeFromLeaf is called

        // Otherwise, removeFromNonLeaf function is called

        if (leaf)

            removeFromLeaf(idx);

        else

            removeFromNonLeaf(idx);

    }

    else

    {

 

        // If this node is a leaf node, then the key is not present in tree

        if (leaf)

        {

            cout << "The key "<< k <<" is does not exist in the tree\n";

            return;

        }

 

        // The key to be removed is present in the sub-tree rooted with this node

        // The flag indicates whether the key is present in the sub-tree rooted

        // with the last child of this node

        bool flag = ( (idx==n)? true : false );

 

        // If the child where the key is supposed to exist has less that t keys,

        // we fill that child

        if (C[idx]->n < t)

            fill(idx);

 

        // If the last child has been merged, it must have merged with the previous

        // child and so we recurse on the (idx-1)th child. Else, we recurse on the

        // (idx)th child which now has atleast t keys

        if (flag && idx > n)

            C[idx-]->remove(k);

        else

            C[idx]->remove(k);

    }

    return;

}

 

// A function to remove the idx-th key from this node - which is a leaf node

void BTreeNode::removeFromLeaf (int idx)

{

 

    // Move all the keys after the idx-th pos one place backward

    for (int i=idx+; i<n; ++i)

        keys[i-] = keys[i];

 

    // Reduce the count of keys

    n--;

 

    return;

}

 

// A function to remove the idx-th key from this node - which is a non-leaf node

void BTreeNode::removeFromNonLeaf(int idx)

{

 

    int k = keys[idx];

 

    // If the child that precedes k (C[idx]) has atleast t keys,

    // find the predecessor 'pred' of k in the subtree rooted at

    // C[idx]. Replace k by pred. Recursively delete pred

    // in C[idx]

    if (C[idx]->n >= t)

    {

        int pred = getPred(idx);

        keys[idx] = pred;

        C[idx]->remove(pred);

    }

 

    // If the child C[idx] has less that t keys, examine C[idx+1].

    // If C[idx+1] has atleast t keys, find the successor 'succ' of k in

    // the subtree rooted at C[idx+1]

    // Replace k by succ

    // Recursively delete succ in C[idx+1]

    else if  (C[idx+]->n >= t)

    {

        int succ = getSucc(idx);

        keys[idx] = succ;

        C[idx+]->remove(succ);

    }

 

    // If both C[idx] and C[idx+1] has less that t keys,merge k and all of C[idx+1]

    // into C[idx]

    // Now C[idx] contains 2t-1 keys

    // Free C[idx+1] and recursively delete k from C[idx]

    else

    {

        merge(idx);

        C[idx]->remove(k);

    }

    return;

}

 

// A function to get predecessor of keys[idx]

int BTreeNode::getPred(int idx)

{

    // Keep moving to the right most node until we reach a leaf

    BTreeNode *cur=C[idx];

    while (!cur->leaf)

        cur = cur->C[cur->n];

 

    // Return the last key of the leaf

    return cur->keys[cur->n-];

}

 

int BTreeNode::getSucc(int idx)

{

 

    // Keep moving the left most node starting from C[idx+1] until we reach a leaf

    BTreeNode *cur = C[idx+];

    while (!cur->leaf)

        cur = cur->C[];

 

    // Return the first key of the leaf

    return cur->keys[];

}

 

// A function to fill child C[idx] which has less than t-1 keys

void BTreeNode::fill(int idx)

{

 

    // If the previous child(C[idx-1]) has more than t-1 keys, borrow a key

    // from that child

    if (idx!= && C[idx-]->n>=t)

        borrowFromPrev(idx);

 

    // If the next child(C[idx+1]) has more than t-1 keys, borrow a key

    // from that child

    else if (idx!=n && C[idx+]->n>=t)

        borrowFromNext(idx);

 

    // Merge C[idx] with its sibling

    // If C[idx] is the last child, merge it with with its previous sibling

    // Otherwise merge it with its next sibling

    else

    {

        if (idx != n)

            merge(idx);

        else

            merge(idx-);

    }

    return;

}

 

// A function to borrow a key from C[idx-1] and insert it

// into C[idx]

void BTreeNode::borrowFromPrev(int idx)

{

 

    BTreeNode *child=C[idx];

    BTreeNode *sibling=C[idx-];

 

    // The last key from C[idx-1] goes up to the parent and key[idx-1]

    // from parent is inserted as the first key in C[idx]. Thus, the  loses

    // sibling one key and child gains one key

 

    // Moving all key in C[idx] one step ahead

    for (int i=child->n-; i>=; --i)

        child->keys[i+] = child->keys[i];

 

    // If C[idx] is not a leaf, move all its child pointers one step ahead

    if (!child->leaf)

    {

        for(int i=child->n; i>=; --i)

            child->C[i+] = child->C[i];

    }

 

    // Setting child's first key equal to keys[idx-1] from the current node

    child->keys[] = keys[idx-];

 

    // Moving sibling's last child as C[idx]'s first child

    if (!leaf)

        child->C[] = sibling->C[sibling->n];

 

    // Moving the key from the sibling to the parent

    // This reduces the number of keys in the sibling

    keys[idx-] = sibling->keys[sibling->n-];

 

    child->n += ;

    sibling->n -= ;

 

    return;

}

 

// A function to borrow a key from the C[idx+1] and place

// it in C[idx]

void BTreeNode::borrowFromNext(int idx)

{

 

    BTreeNode *child=C[idx];

    BTreeNode *sibling=C[idx+];

 

    // keys[idx] is inserted as the last key in C[idx]

    child->keys[(child->n)] = keys[idx];

 

    // Sibling's first child is inserted as the last child

    // into C[idx]

    if (!(child->leaf))

        child->C[(child->n)+] = sibling->C[];

 

    //The first key from sibling is inserted into keys[idx]

    keys[idx] = sibling->keys[];

 

    // Moving all keys in sibling one step behind

    for (int i=; i<sibling->n; ++i)

        sibling->keys[i-] = sibling->keys[i];

 

    // Moving the child pointers one step behind

    if (!sibling->leaf)

    {

        for(int i=; i<=sibling->n; ++i)

            sibling->C[i-] = sibling->C[i];

    }

 

    // Increasing and decreasing the key count of C[idx] and C[idx+1]

    // respectively

    child->n += ;

    sibling->n -= ;

 

    return;

}

 

// A function to merge C[idx] with C[idx+1]

// C[idx+1] is freed after merging

void BTreeNode::merge(int idx)

{

    BTreeNode *child = C[idx];

    BTreeNode *sibling = C[idx+];

 

    // Pulling a key from the current node and inserting it into (t-1)th

    // position of C[idx]

    child->keys[t-] = keys[idx];

 

    // Copying the keys from C[idx+1] to C[idx] at the end

    for (int i=; i<sibling->n; ++i)

        child->keys[i+t] = sibling->keys[i];

 

    // Copying the child pointers from C[idx+1] to C[idx]

    if (!child->leaf)

    {

        for(int i=; i<=sibling->n; ++i)

            child->C[i+t] = sibling->C[i];

    }

 

    // Moving all keys after idx in the current node one step before -

    // to fill the gap created by moving keys[idx] to C[idx]

    for (int i=idx+; i<n; ++i)

        keys[i-] = keys[i];

 

    // Moving the child pointers after (idx+1) in the current node one

    // step before

    for (int i=idx+; i<=n; ++i)

        C[i-] = C[i];

 

    // Updating the key count of child and the current node

    child->n += sibling->n+;

    n--;

 

    // Freeing the memory occupied by sibling

    delete(sibling);

    return;

}

 

// 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[] = k;  // Insert key

        root->n = ;  // Update number of keys in root

    }

    else // If tree is not empty

    {

        // If root is full, then tree grows in height

        if (root->n == *t-)

        {

            // Allocate memory for new root

            BTreeNode *s = new BTreeNode(t, false);

 

            // Make old root as child of new root

            s->C[] = root;

 

            // Split the old root and move 1 key to the new root

            s->splitChild(, root);

 

            // New root has two children now.  Decide which of the

            // two children is going to have new key

            int i = ;

            if (s->keys[] < 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-;

 

    // 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 >=  && keys[i] > k)

        {

            keys[i+] = keys[i];

            i--;

        }

 

        // Insert the new key at found location

        keys[i+] = k;

        n = n+;

    }

    else // If this node is not leaf

    {

        // Find the child which is going to have the new key

        while (i >=  && keys[i] > k)

            i--;

 

        // See if the found child is full

        if (C[i+]->n == *t-)

        {

            // If the child is full, then split it

            splitChild(i+, C[i+]);

 

            // 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+] < k)

                i++;

        }

        C[i+]->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 - ;

 

    // Copy the last (t-1) keys of y to z

    for (int j = ; j < t-; j++)

        z->keys[j] = y->keys[j+t];

 

    // Copy the last t children of y to z

    if (y->leaf == false)

    {

        for (int j = ; j < t; j++)

            z->C[j] = y->C[j+t];

    }

 

    // Reduce the number of keys in y

    y->n = t - ;

 

    // Since this node is going to have a new child,

    // create space of new child

    for (int j = n; j >= i+; j--)

        C[j+] = C[j];

 

    // Link the new child to this node

    C[i+] = z;

 

    // A key of y will move to this node. Find location of

    // new key and move all greater keys one space ahead

    for (int j = n-; j >= i; j--)

        keys[j+] = keys[j];

 

    // Copy the middle key of y to this node

    keys[i] = y->keys[t-];

 

    // Increment count of keys in this node

    n = n + ;

}

 

// Function to traverse all nodes in a subtree rooted with this node

void BTreeNode::traverse()

{

    // There are n keys and n+1 children, travers through n keys

    // and first n children

    int i;

    for (i = ; 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 = ;

    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);

}

 

void BTree::remove(int k)

{

    if (!root)

    {

        cout << "The tree is empty\n";

        return;

    }

 

    // Call the remove function for root

    root->remove(k);

 

    // If the root node has 0 keys, make its first child as the new root

    //  if it has a child, otherwise set root as NULL

    if (root->n==)

    {

        BTreeNode *tmp = root;

        if (root->leaf)

            root = NULL;

        else

            root = root->C[];

 

        // Free the old root

        delete tmp;

    }

    return;

}

 

// Driver program to test above functions

int main()

{

    BTree t(); // A B-Tree with minium degree 3

 

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

    t.insert();

 

    cout << "Traversal of tree constructed is\n";

    t.traverse();

    cout << endl;

 

    t.remove();

    cout << "Traversal of tree after removing 6\n";

    t.traverse();

    cout << endl;

 

    t.remove();

    cout << "Traversal of tree after removing 13\n";

    t.traverse();

    cout << endl;

 

    t.remove();

    cout << "Traversal of tree after removing 7\n";

    t.traverse();

    cout << endl;

 

    t.remove();

    cout << "Traversal of tree after removing 4\n";

    t.traverse();

    cout << endl;

 

    t.remove();

    cout << "Traversal of tree after removing 2\n";

    t.traverse();

    cout << endl;

 

    t.remove();

    cout << "Traversal of tree after removing 16\n";

    t.traverse();

    cout << endl;

 

    return ;

}

Traversal of tree constructed is

Traversal of tree after removing 

Traversal of tree after removing 

Traversal of tree after removing 

Traversal of tree after removing 

Traversal of tree after removing 

Traversal of tree after removing