/*
* bpt.c
*/
#define Version "1.13"
/*
*
* bpt: B+ Tree Implementation
* Copyright (C) 2010 Amittai Aviram http://www.amittai.com
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*
* Author: Amittai Aviram
* http://www.amittai.com
* amittai.aviram@gmail.edu or afa13@columbia.edu
* Senior Software Engineer
* MathWorks, Inc.
* 3 Apple Hill Drive
* Natick, MA 01760
* Original Date: 26 June 2010
* Last modified: 15 April 2014
*
* This implementation demonstrates the B+ tree data structure
* for educational purposes, includin insertion, deletion, search, and display
* of the search path, the leaves, or the whole tree.
*
* Must be compiled with a C99-compliant C compiler such as the latest GCC.
*
* Usage: bpt [order]
* where order is an optional argument
* (integer MIN_ORDER <= order <= MAX_ORDER)
* defined as the maximal number of pointers in any node.
*
*/
// Uncomment the line below if you are compiling on Windows.
// #define WINDOWS
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#ifdef WINDOWS
#define bool char
#define false 0
#define true 1
#endif
// Default order is 4.
#define DEFAULT_ORDER 4
// Minimum order is necessarily 3. We set the maximum
// order arbitrarily. You may change the maximum order.
#define MIN_ORDER 3
#define MAX_ORDER 20
// Constants for printing part or all of the GPL license.
#define LICENSE_FILE "LICENSE.txt"
#define LICENSE_WARRANTEE 0
#define LICENSE_WARRANTEE_START 592
#define LICENSE_WARRANTEE_END 624
#define LICENSE_CONDITIONS 1
#define LICENSE_CONDITIONS_START 70
#define LICENSE_CONDITIONS_END 625
// TYPES.
/* Type representing the record
* to which a given key refers.
* In a real B+ tree system, the
* record would hold data (in a database)
* or a file (in an operating system)
* or some other information.
* Users can rewrite this part of the code
* to change the type and content
* of the value field.
*/
typedef struct record {
int value;
} record;
/* Type representing a node in the B+ tree.
* This type is general enough to serve for both
* the leaf and the internal node.
* The heart of the node is the array
* of keys and the array of corresponding
* pointers. The relation between keys
* and pointers differs between leaves and
* internal nodes. In a leaf, the index
* of each key equals the index of its corresponding
* pointer, with a maximum of order - 1 key-pointer
* pairs. The last pointer points to the
* leaf to the right (or NULL in the case
* of the rightmost leaf).
* In an internal node, the first pointer
* refers to lower nodes with keys less than
* the smallest key in the keys array. Then,
* with indices i starting at 0, the pointer
* at i + 1 points to the subtree with keys
* greater than or equal to the key in this
* node at index i.
* The num_keys field is used to keep
* track of the number of valid keys.
* In an internal node, the number of valid
* pointers is always num_keys + 1.
* In a leaf, the number of valid pointers
* to data is always num_keys. The
* last leaf pointer points to the next leaf.
*/
typedef struct node {
void ** pointers;
int * keys;
struct node * parent;
bool is_leaf;
int num_keys;
struct node * next; // Used for queue.
} node;
// GLOBALS.
/* The order determines the maximum and minimum
* number of entries (keys and pointers) in any
* node. Every node has at most order - 1 keys and
* at least (roughly speaking) half that number.
* Every leaf has as many pointers to data as keys,
* and every internal node has one more pointer
* to a subtree than the number of keys.
* This global variable is initialized to the
* default value.
*/
int order = DEFAULT_ORDER;
/* The queue is used to print the tree in
* level order, starting from the root
* printing each entire rank on a separate
* line, finishing with the leaves.
*/
node * queue = NULL;
/* The user can toggle on and off the "verbose"
* property, which causes the pointer addresses
* to be printed out in hexadecimal notation
* next to their corresponding keys.
*/
bool verbose_output = false;
// FUNCTION PROTOTYPES.
// Output and utility.
void license_notice( void );
void print_license( int licence_part );
void usage_1( void );
void usage_2( void );
void usage_3( void );
void enqueue( node * new_node );
node * dequeue( void );
int height( node * root );
int path_to_root( node * root, node * child );
void print_leaves( node * root );
void print_tree( node * root );
void find_and_print(node * root, int key, bool verbose);
void find_and_print_range(node * root, int range1, int range2, bool verbose);
int find_range( node * root, int key_start, int key_end, bool verbose,
int returned_keys[], void * returned_pointers[]);
node * find_leaf( node * root, int key, bool verbose );
record * find( node * root, int key, bool verbose );
int cut( int length );
// Insertion.
record * make_record(int value);
node * make_node( void );
node * make_leaf( void );
int get_left_index(node * parent, node * left);
node * insert_into_leaf( node * leaf, int key, record * pointer );
node * insert_into_leaf_after_splitting(node * root, node * leaf, int key, record * pointer);
node * insert_into_node(node * root, node * parent,
int left_index, int key, node * right);
node * insert_into_node_after_splitting(node * root, node * parent, int left_index,
int key, node * right);
node * insert_into_parent(node * root, node * left, int key, node * right);
node * insert_into_new_root(node * left, int key, node * right);
node * start_new_tree(int key, record * pointer);
node * insert( node * root, int key, int value );
// Deletion.
int get_neighbor_index( node * n );
node * adjust_root(node * root);
node * coalesce_nodes(node * root, node * n, node * neighbor, int neighbor_index, int k_prime);
node * redistribute_nodes(node * root, node * n, node * neighbor, int neighbor_index,
int k_prime_index, int k_prime);
node * delete_entry( node * root, node * n, int key, void * pointer );
node * delete( node * root, int key );
// FUNCTION DEFINITIONS.
// OUTPUT AND UTILITIES
/* Copyright and license notice to user at startup.
*/
void license_notice( void ) {
printf("bpt version %s -- Copyright (C) 2010 Amittai Aviram "
"http://www.amittai.com\n", Version);
printf("This program comes with ABSOLUTELY NO WARRANTY; for details "
"type `show w'.\n"
"This is free software, and you are welcome to redistribute it\n"
"under certain conditions; type `show c' for details.\n\n");
}
/* Routine to print portion of GPL license to stdout.
*/
void print_license( int license_part ) {
int start, end, line;
FILE * fp;
char buffer[0x100];
switch(license_part) {
case LICENSE_WARRANTEE:
start = LICENSE_WARRANTEE_START;
end = LICENSE_WARRANTEE_END;
break;
case LICENSE_CONDITIONS:
start = LICENSE_CONDITIONS_START;
end = LICENSE_CONDITIONS_END;
break;
default:
return;
}
fp = fopen(LICENSE_FILE, "r");
if (fp == NULL) {
perror("print_license: fopen");
exit(EXIT_FAILURE);
}
for (line = 0; line < start; line++)
fgets(buffer, sizeof(buffer), fp);
for ( ; line < end; line++) {
fgets(buffer, sizeof(buffer), fp);
printf("%s", buffer);
}
fclose(fp);
}
/* First message to the user.
*/
void usage_1( void ) {
printf("B+ Tree of Order %d.\n", order);
printf("Following Silberschatz, Korth, Sidarshan, Database Concepts, 5th ed.\n\n");
printf("To build a B+ tree of a different order, start again and enter the order\n");
printf("as an integer argument: bpt <order> ");
printf("(%d <= order <= %d).\n", MIN_ORDER, MAX_ORDER);
printf("To start with input from a file of newline-delimited integers, \n"
"start again and enter ");
printf("the order followed by the filename:\n"
"bpt <order> <inputfile> .\n");
}
/* Second message to the user.
*/
void usage_2( void ) {
printf("Enter any of the following commands after the prompt > :\n");
printf("\ti <k> -- Insert <k> (an integer) as both key and value).\n");
printf("\tf <k> -- Find the value under key <k>.\n");
printf("\tp <k> -- Print the path from the root to key k and its associated value.\n");
printf("\tr <k1> <k2> -- Print the keys and values found in the range "
"[<k1>, <k2>\n");
printf("\td <k> -- Delete key <k> and its associated value.\n");
printf("\tx -- Destroy the whole tree. Start again with an empty tree of the same order.\n");
printf("\tt -- Print the B+ tree.\n");
printf("\tl -- Print the keys of the leaves (bottom row of the tree).\n");
printf("\tv -- Toggle output of pointer addresses (\"verbose\") in tree and leaves.\n");
printf("\tq -- Quit. (Or use Ctl-D.)\n");
printf("\t? -- Print this help message.\n");
}
/* Brief usage note.
*/
void usage_3( void ) {
printf("Usage: ./bpt [<order>]\n");
printf("\twhere %d <= order <= %d .\n", MIN_ORDER, MAX_ORDER);
}
/* Helper function for printing the
* tree out. See print_tree.
*/
void enqueue( node * new_node ) {
node * c;
if (queue == NULL) {
queue = new_node;
queue->next = NULL;
}
else {
c = queue;
while(c->next != NULL) {
c = c->next;
}
c->next = new_node;
new_node->next = NULL;
}
}
/* Helper function for printing the
* tree out. See print_tree.
*/
node * dequeue( void ) {
node * n = queue;
queue = queue->next;
n->next = NULL;
return n;
}
/* Prints the bottom row of keys
* of the tree (with their respective
* pointers, if the verbose_output flag is set.
*/
void print_leaves( node * root ) {
int i;
node * c = root;
if (root == NULL) {
printf("Empty tree.\n");
return;
}
while (!c->is_leaf)
c = c->pointers[0];
while (true) {
for (i = 0; i < c->num_keys; i++) {
if (verbose_output)
printf("%lx ", (unsigned long)c->pointers[i]);
printf("%d ", c->keys[i]);
}
if (verbose_output)
printf("%lx ", (unsigned long)c->pointers[order - 1]);
if (c->pointers[order - 1] != NULL) {
printf(" | ");
c = c->pointers[order - 1];
}
else
break;
}
printf("\n");
}
/* Utility function to give the height
* of the tree, which length in number of edges
* of the path from the root to any leaf.
*/
int height( node * root ) {
int h = 0;
node * c = root;
while (!c->is_leaf) {
c = c->pointers[0];
h++;
}
return h;
}
/* Utility function to give the length in edges
* of the path from any node to the root.
*/
int path_to_root( node * root, node * child ) {
int length = 0;
node * c = child;
while (c != root) {
c = c->parent;
length++;
}
return length;
}
/* Prints the B+ tree in the command
* line in level (rank) order, with the
* keys in each node and the '|' symbol
* to separate nodes.
* With the verbose_output flag set.
* the values of the pointers corresponding
* to the keys also appear next to their respective
* keys, in hexadecimal notation.
*/
void print_tree( node * root ) {
node * n = NULL;
int i = 0;
int rank = 0;
int new_rank = 0;
if (root == NULL) {
printf("Empty tree.\n");
return;
}
queue = NULL;
enqueue(root);
while( queue != NULL ) {
n = dequeue();
if (n->parent != NULL && n == n->parent->pointers[0]) {
new_rank = path_to_root( root, n );
if (new_rank != rank) {
rank = new_rank;
printf("\n");
}
}
if (verbose_output)
printf("(%lx)", (unsigned long)n);
for (i = 0; i < n->num_keys; i++) {
if (verbose_output)
printf("%lx ", (unsigned long)n->pointers[i]);
printf("%d ", n->keys[i]);
}
if (!n->is_leaf)
for (i = 0; i <= n->num_keys; i++)
enqueue(n->pointers[i]);
if (verbose_output) {
if (n->is_leaf)
printf("%lx ", (unsigned long)n->pointers[order - 1]);
else
printf("%lx ", (unsigned long)n->pointers[n->num_keys]);
}
printf("| ");
}
printf("\n");
}
/* Finds the record under a given key and prints an
* appropriate message to stdout.
*/
void find_and_print(node * root, int key, bool verbose) {
record * r = find(root, key, verbose);
if (r == NULL)
printf("Record not found under key %d.\n", key);
else
printf("Record at %lx -- key %d, value %d.\n",
(unsigned long)r, key, r->value);
}
/* Finds and prints the keys, pointers, and values within a range
* of keys between key_start and key_end, including both bounds.
*/
void find_and_print_range( node * root, int key_start, int key_end,
bool verbose ) {
int i;
int array_size = key_end - key_start + 1;
int returned_keys[array_size];
void * returned_pointers[array_size];
int num_found = find_range( root, key_start, key_end, verbose,
returned_keys, returned_pointers );
if (!num_found)
printf("None found.\n");
else {
for (i = 0; i < num_found; i++)
printf("Key: %d Location: %lx Value: %d\n",
returned_keys[i],
(unsigned long)returned_pointers[i],
((record *)
returned_pointers[i])->value);
}
}
/* Finds keys and their pointers, if present, in the range specified
* by key_start and key_end, inclusive. Places these in the arrays
* returned_keys and returned_pointers, and returns the number of
* entries found.
*/
int find_range( node * root, int key_start, int key_end, bool verbose,
int returned_keys[], void * returned_pointers[]) {
int i, num_found;
num_found = 0;
node * n = find_leaf( root, key_start, verbose );
if (n == NULL) return 0;
for (i = 0; i < n->num_keys && n->keys[i] < key_start; i++) ;
if (i == n->num_keys) return 0;
while (n != NULL) {
for ( ; i < n->num_keys && n->keys[i] <= key_end; i++) {
returned_keys[num_found] = n->keys[i];
returned_pointers[num_found] = n->pointers[i];
num_found++;
}
n = n->pointers[order - 1];
i = 0;
}
return num_found;
}
/* Traces the path from the root to a leaf, searching
* by key. Displays information about the path
* if the verbose flag is set.
* Returns the leaf containing the given key.
*/
node * find_leaf( node * root, int key, bool verbose ) {
int i = 0;
node * c = root;
if (c == NULL) {
if (verbose)
printf("Empty tree.\n");
return c;
}
while (!c->is_leaf) {
if (verbose) {
printf("[");
for (i = 0; i < c->num_keys - 1; i++)
printf("%d ", c->keys[i]);
printf("%d] ", c->keys[i]);
}
i = 0;
while (i < c->num_keys) {
if (key >= c->keys[i]) i++;
else break;
}
if (verbose)
printf("%d ->\n", i);
c = (node *)c->pointers[i];
}
if (verbose) {
printf("Leaf [");
for (i = 0; i < c->num_keys - 1; i++)
printf("%d ", c->keys[i]);
printf("%d] ->\n", c->keys[i]);
}
return c;
}
/* Finds and returns the record to which
* a key refers.
*/
record * find( node * root, int key, bool verbose ) {
int i = 0;
node * c = find_leaf( root, key, verbose );
if (c == NULL) return NULL;
for (i = 0; i < c->num_keys; i++)
if (c->keys[i] == key) break;
if (i == c->num_keys)
return NULL;
else
return (record *)c->pointers[i];
}
/* Finds the appropriate place to
* split a node that is too big into two.
*/
int cut( int length ) {
if (length % 2 == 0)
return length/2;
else
return length/2 + 1;
}
// INSERTION
/* Creates a new record to hold the value
* to which a key refers.
*/
record * make_record(int value) {
record * new_record = (record *)malloc(sizeof(record));
if (new_record == NULL) {
perror("Record creation.");
exit(EXIT_FAILURE);
}
else {
new_record->value = value;
}
return new_record;
}
/* Creates a new general node, which can be adapted
* to serve as either a leaf or an internal node.
*/
node * make_node( void ) {
node * new_node;
new_node = malloc(sizeof(node));
if (new_node == NULL) {
perror("Node creation.");
exit(EXIT_FAILURE);
}
new_node->keys = malloc( (order - 1) * sizeof(int) );
if (new_node->keys == NULL) {
perror("New node keys array.");
exit(EXIT_FAILURE);
}
new_node->pointers = malloc( order * sizeof(void *) );
if (new_node->pointers == NULL) {
perror("New node pointers array.");
exit(EXIT_FAILURE);
}
new_node->is_leaf = false;
new_node->num_keys = 0;
new_node->parent = NULL;
new_node->next = NULL;
return new_node;
}
/* Creates a new leaf by creating a node
* and then adapting it appropriately.
*/
node * make_leaf( void ) {
node * leaf = make_node();
leaf->is_leaf = true;
return leaf;
}
/* Helper function used in insert_into_parent
* to find the index of the parent's pointer to
* the node to the left of the key to be inserted.
*/
int get_left_index(node * parent, node * left) {
int left_index = 0;
while (left_index <= parent->num_keys &&
parent->pointers[left_index] != left)
left_index++;
return left_index;
}
/* Inserts a new pointer to a record and its corresponding
* key into a leaf.
* Returns the altered leaf.
*/
node * insert_into_leaf( node * leaf, int key, record * pointer ) {
int i, insertion_point;
insertion_point = 0;
while (insertion_point < leaf->num_keys && leaf->keys[insertion_point] < key)
insertion_point++;
for (i = leaf->num_keys; i > insertion_point; i--) {
leaf->keys[i] = leaf->keys[i - 1];
leaf->pointers[i] = leaf->pointers[i - 1];
}
leaf->keys[insertion_point] = key;
leaf->pointers[insertion_point] = pointer;
leaf->num_keys++;
return leaf;
}
/* Inserts a new key and pointer
* to a new record into a leaf so as to exceed
* the tree's order, causing the leaf to be split
* in half.
*/
node * insert_into_leaf_after_splitting(node * root, node * leaf, int key, record * pointer) {
node * new_leaf;
int * temp_keys;
void ** temp_pointers;
int insertion_index, split, new_key, i, j;
new_leaf = make_leaf();
temp_keys = malloc( order * sizeof(int) );
if (temp_keys == NULL) {
perror("Temporary keys array.");
exit(EXIT_FAILURE);
}
temp_pointers = malloc( order * sizeof(void *) );
if (temp_pointers == NULL) {
perror("Temporary pointers array.");
exit(EXIT_FAILURE);
}
insertion_index = 0;
while (insertion_index < order - 1 && leaf->keys[insertion_index] < key)
insertion_index++;
for (i = 0, j = 0; i < leaf->num_keys; i++, j++) {
if (j == insertion_index) j++;
temp_keys[j] = leaf->keys[i];
temp_pointers[j] = leaf->pointers[i];
}
temp_keys[insertion_index] = key;
temp_pointers[insertion_index] = pointer;
leaf->num_keys = 0;
split = cut(order - 1);
for (i = 0; i < split; i++) {
leaf->pointers[i] = temp_pointers[i];
leaf->keys[i] = temp_keys[i];
leaf->num_keys++;
}
for (i = split, j = 0; i < order; i++, j++) {
new_leaf->pointers[j] = temp_pointers[i];
new_leaf->keys[j] = temp_keys[i];
new_leaf->num_keys++;
}
free(temp_pointers);
free(temp_keys);
new_leaf->pointers[order - 1] = leaf->pointers[order - 1];
leaf->pointers[order - 1] = new_leaf;
for (i = leaf->num_keys; i < order - 1; i++)
leaf->pointers[i] = NULL;
for (i = new_leaf->num_keys; i < order - 1; i++)
new_leaf->pointers[i] = NULL;
new_leaf->parent = leaf->parent;
new_key = new_leaf->keys[0];
return insert_into_parent(root, leaf, new_key, new_leaf);
}
/* Inserts a new key and pointer to a node
* into a node into which these can fit
* without violating the B+ tree properties.
*/
node * insert_into_node(node * root, node * n,
int left_index, int key, node * right) {
int i;
for (i = n->num_keys; i > left_index; i--) {
n->pointers[i + 1] = n->pointers[i];
n->keys[i] = n->keys[i - 1];
}
n->pointers[left_index + 1] = right;
n->keys[left_index] = key;
n->num_keys++;
return root;
}
/* Inserts a new key and pointer to a node
* into a node, causing the node's size to exceed
* the order, and causing the node to split into two.
*/
node * insert_into_node_after_splitting(node * root, node * old_node, int left_index,
int key, node * right) {
int i, j, split, k_prime;
node * new_node, * child;
int * temp_keys;
node ** temp_pointers;
/* First create a temporary set of keys and pointers
* to hold everything in order, including
* the new key and pointer, inserted in their
* correct places.
* Then create a new node and copy half of the
* keys and pointers to the old node and
* the other half to the new.
*/
temp_pointers = malloc( (order + 1) * sizeof(node *) );
if (temp_pointers == NULL) {
perror("Temporary pointers array for splitting nodes.");
exit(EXIT_FAILURE);
}
temp_keys = malloc( order * sizeof(int) );
if (temp_keys == NULL) {
perror("Temporary keys array for splitting nodes.");
exit(EXIT_FAILURE);
}
for (i = 0, j = 0; i < old_node->num_keys + 1; i++, j++) {
if (j == left_index + 1) j++;
temp_pointers[j] = old_node->pointers[i];
}
for (i = 0, j = 0; i < old_node->num_keys; i++, j++) {
if (j == left_index) j++;
temp_keys[j] = old_node->keys[i];
}
temp_pointers[left_index + 1] = right;
temp_keys[left_index] = key;
/* Create the new node and copy
* half the keys and pointers to the
* old and half to the new.
*/
split = cut(order);
new_node = make_node();
old_node->num_keys = 0;
for (i = 0; i < split - 1; i++) {
old_node->pointers[i] = temp_pointers[i];
old_node->keys[i] = temp_keys[i];
old_node->num_keys++;
}
old_node->pointers[i] = temp_pointers[i];
k_prime = temp_keys[split - 1];
for (++i, j = 0; i < order; i++, j++) {
new_node->pointers[j] = temp_pointers[i];
new_node->keys[j] = temp_keys[i];
new_node->num_keys++;
}
new_node->pointers[j] = temp_pointers[i];
free(temp_pointers);
free(temp_keys);
new_node->parent = old_node->parent;
for (i = 0; i <= new_node->num_keys; i++) {
child = new_node->pointers[i];
child->parent = new_node;
}
/* Insert a new key into the parent of the two
* nodes resulting from the split, with
* the old node to the left and the new to the right.
*/
return insert_into_parent(root, old_node, k_prime, new_node);
}
/* Inserts a new node (leaf or internal node) into the B+ tree.
* Returns the root of the tree after insertion.
*/
node * insert_into_parent(node * root, node * left, int key, node * right) {
int left_index;
node * parent;
parent = left->parent;
/* Case: new root. */
if (parent == NULL)
return insert_into_new_root(left, key, right);
/* Case: leaf or node. (Remainder of
* function body.)
*/
/* Find the parent's pointer to the left
* node.
*/
left_index = get_left_index(parent, left);
/* Simple case: the new key fits into the node.
*/
if (parent->num_keys < order - 1)
return insert_into_node(root, parent, left_index, key, right);
/* Harder case: split a node in order
* to preserve the B+ tree properties.
*/
return insert_into_node_after_splitting(root, parent, left_index, key, right);
}
/* Creates a new root for two subtrees
* and inserts the appropriate key into
* the new root.
*/
node * insert_into_new_root(node * left, int key, node * right) {
node * root = make_node();
root->keys[0] = key;
root->pointers[0] = left;
root->pointers[1] = right;
root->num_keys++;
root->parent = NULL;
left->parent = root;
right->parent = root;
return root;
}
/* First insertion:
* start a new tree.
*/
node * start_new_tree(int key, record * pointer) {
node * root = make_leaf();
root->keys[0] = key;
root->pointers[0] = pointer;
root->pointers[order - 1] = NULL;
root->parent = NULL;
root->num_keys++;
return root;
}
/* Master insertion function.
* Inserts a key and an associated value into
* the B+ tree, causing the tree to be adjusted
* however necessary to maintain the B+ tree
* properties.
*/
node * insert( node * root, int key, int value ) {
record * pointer;
node * leaf;
/* The current implementation ignores
* duplicates.
*/
if (find(root, key, false) != NULL)
return root;
/* Create a new record for the
* value.
*/
pointer = make_record(value);
/* Case: the tree does not exist yet.
* Start a new tree.
*/
if (root == NULL)
return start_new_tree(key, pointer);
/* Case: the tree already exists.
* (Rest of function body.)
*/
leaf = find_leaf(root, key, false);
/* Case: leaf has room for key and pointer.
*/
if (leaf->num_keys < order - 1) {
leaf = insert_into_leaf(leaf, key, pointer);
return root;
}
/* Case: leaf must be split.
*/
return insert_into_leaf_after_splitting(root, leaf, key, pointer);
}
// DELETION.
/* Utility function for deletion. Retrieves
* the index of a node's nearest neighbor (sibling)
* to the left if one exists. If not (the node
* is the leftmost child), returns -1 to signify
* this special case.
*/
int get_neighbor_index( node * n ) {
int i;
/* Return the index of the key to the left
* of the pointer in the parent pointing
* to n.
* If n is the leftmost child, this means
* return -1.
*/
for (i = 0; i <= n->parent->num_keys; i++)
if (n->parent->pointers[i] == n)
return i - 1;
// Error state.
printf("Search for nonexistent pointer to node in parent.\n");
printf("Node: %#lx\n", (unsigned long)n);
exit(EXIT_FAILURE);
}
node * remove_entry_from_node(node * n, int key, node * pointer) {
int i, num_pointers;
// Remove the key and shift other keys accordingly.
i = 0;
while (n->keys[i] != key)
i++;
for (++i; i < n->num_keys; i++)
n->keys[i - 1] = n->keys[i];
// Remove the pointer and shift other pointers accordingly.
// First determine number of pointers.
num_pointers = n->is_leaf ? n->num_keys : n->num_keys + 1;
i = 0;
while (n->pointers[i] != pointer)
i++;
for (++i; i < num_pointers; i++)
n->pointers[i - 1] = n->pointers[i];
// One key fewer.
n->num_keys--;
// Set the other pointers to NULL for tidiness.
// A leaf uses the last pointer to point to the next leaf.
if (n->is_leaf)
for (i = n->num_keys; i < order - 1; i++)
n->pointers[i] = NULL;
else
for (i = n->num_keys + 1; i < order; i++)
n->pointers[i] = NULL;
return n;
}
node * adjust_root(node * root) {
node * new_root;
/* Case: nonempty root.
* Key and pointer have already been deleted,
* so nothing to be done.
*/
if (root->num_keys > 0)
return root;
/* Case: empty root.
*/
// If it has a child, promote
// the first (only) child
// as the new root.
if (!root->is_leaf) {
new_root = root->pointers[0];
new_root->parent = NULL;
}
// If it is a leaf (has no children),
// then the whole tree is empty.
else
new_root = NULL;
free(root->keys);
free(root->pointers);
free(root);
return new_root;
}
/* Coalesces a node that has become
* too small after deletion
* with a neighboring node that
* can accept the additional entries
* without exceeding the maximum.
*/
node * coalesce_nodes(node * root, node * n, node * neighbor, int neighbor_index, int k_prime) {
int i, j, neighbor_insertion_index, n_end;
node * tmp;
/* Swap neighbor with node if node is on the
* extreme left and neighbor is to its right.
*/
if (neighbor_index == -1) {
tmp = n;
n = neighbor;
neighbor = tmp;
}
/* Starting point in the neighbor for copying
* keys and pointers from n.
* Recall that n and neighbor have swapped places
* in the special case of n being a leftmost child.
*/
neighbor_insertion_index = neighbor->num_keys;
/* Case: nonleaf node.
* Append k_prime and the following pointer.
* Append all pointers and keys from the neighbor.
*/
if (!n->is_leaf) {
/* Append k_prime.
*/
neighbor->keys[neighbor_insertion_index] = k_prime;
neighbor->num_keys++;
n_end = n->num_keys;
for (i = neighbor_insertion_index + 1, j = 0; j < n_end; i++, j++) {
neighbor->keys[i] = n->keys[j];
neighbor->pointers[i] = n->pointers[j];
neighbor->num_keys++;
n->num_keys--;
}
/* The number of pointers is always
* one more than the number of keys.
*/
neighbor->pointers[i] = n->pointers[j];
/* All children must now point up to the same parent.
*/
for (i = 0; i < neighbor->num_keys + 1; i++) {
tmp = (node *)neighbor->pointers[i];
tmp->parent = neighbor;
}
}
/* In a leaf, append the keys and pointers of
* n to the neighbor.
* Set the neighbor's last pointer to point to
* what had been n's right neighbor.
*/
else {
for (i = neighbor_insertion_index, j = 0; j < n->num_keys; i++, j++) {
neighbor->keys[i] = n->keys[j];
neighbor->pointers[i] = n->pointers[j];
neighbor->num_keys++;
}
neighbor->pointers[order - 1] = n->pointers[order - 1];
}
root = delete_entry(root, n->parent, k_prime, n);
free(n->keys);
free(n->pointers);
free(n);
return root;
}
/* Redistributes entries between two nodes when
* one has become too small after deletion
* but its neighbor is too big to append the
* small node's entries without exceeding the
* maximum
*/
node * redistribute_nodes(node * root, node * n, node * neighbor, int neighbor_index,
int k_prime_index, int k_prime) {
int i;
node * tmp;
/* Case: n has a neighbor to the left.
* Pull the neighbor's last key-pointer pair over
* from the neighbor's right end to n's left end.
*/
if (neighbor_index != -1) {
if (!n->is_leaf)
n->pointers[n->num_keys + 1] = n->pointers[n->num_keys];
for (i = n->num_keys; i > 0; i--) {
n->keys[i] = n->keys[i - 1];
n->pointers[i] = n->pointers[i - 1];
}
if (!n->is_leaf) {
n->pointers[0] = neighbor->pointers[neighbor->num_keys];
tmp = (node *)n->pointers[0];
tmp->parent = n;
neighbor->pointers[neighbor->num_keys] = NULL;
n->keys[0] = k_prime;
n->parent->keys[k_prime_index] = neighbor->keys[neighbor->num_keys - 1];
}
else {
n->pointers[0] = neighbor->pointers[neighbor->num_keys - 1];
neighbor->pointers[neighbor->num_keys - 1] = NULL;
n->keys[0] = neighbor->keys[neighbor->num_keys - 1];
n->parent->keys[k_prime_index] = n->keys[0];
}
}
/* Case: n is the leftmost child.
* Take a key-pointer pair from the neighbor to the right.
* Move the neighbor's leftmost key-pointer pair
* to n's rightmost position.
*/
else {
if (n->is_leaf) {
n->keys[n->num_keys] = neighbor->keys[0];
n->pointers[n->num_keys] = neighbor->pointers[0];
n->parent->keys[k_prime_index] = neighbor->keys[1];
}
else {
n->keys[n->num_keys] = k_prime;
n->pointers[n->num_keys + 1] = neighbor->pointers[0];
tmp = (node *)n->pointers[n->num_keys + 1];
tmp->parent = n;
n->parent->keys[k_prime_index] = neighbor->keys[0];
}
for (i = 0; i < neighbor->num_keys - 1; i++) {
neighbor->keys[i] = neighbor->keys[i + 1];
neighbor->pointers[i] = neighbor->pointers[i + 1];
}
if (!n->is_leaf)
neighbor->pointers[i] = neighbor->pointers[i + 1];
}
/* n now has one more key and one more pointer;
* the neighbor has one fewer of each.
*/
n->num_keys++;
neighbor->num_keys--;
return root;
}
/* Deletes an entry from the B+ tree.
* Removes the record and its key and pointer
* from the leaf, and then makes all appropriate
* changes to preserve the B+ tree properties.
*/
node * delete_entry( node * root, node * n, int key, void * pointer ) {
int min_keys;
node * neighbor;
int neighbor_index;
int k_prime_index, k_prime;
int capacity;
// Remove key and pointer from node.
n = remove_entry_from_node(n, key, pointer);
/* Case: deletion from the root.
*/
if (n == root)
return adjust_root(root);
/* Case: deletion from a node below the root.
* (Rest of function body.)
*/
/* Determine minimum allowable size of node,
* to be preserved after deletion.
*/
min_keys = n->is_leaf ? cut(order - 1) : cut(order) - 1;
/* Case: node stays at or above minimum.
* (The simple case.)
*/
if (n->num_keys >= min_keys)
return root;
/* Case: node falls below minimum.
* Either coalescence or redistribution
* is needed.
*/
/* Find the appropriate neighbor node with which
* to coalesce.
* Also find the key (k_prime) in the parent
* between the pointer to node n and the pointer
* to the neighbor.
*/
neighbor_index = get_neighbor_index( n );
k_prime_index = neighbor_index == -1 ? 0 : neighbor_index;
k_prime = n->parent->keys[k_prime_index];
neighbor = neighbor_index == -1 ? n->parent->pointers[1] :
n->parent->pointers[neighbor_index];
capacity = n->is_leaf ? order : order - 1;
/* Coalescence. */
if (neighbor->num_keys + n->num_keys < capacity)
return coalesce_nodes(root, n, neighbor, neighbor_index, k_prime);
/* Redistribution. */
else
return redistribute_nodes(root, n, neighbor, neighbor_index, k_prime_index, k_prime);
}
/* Master deletion function.
*/
node * delete(node * root, int key) {
node * key_leaf;
record * key_record;
key_record = find(root, key, false);
key_leaf = find_leaf(root, key, false);
if (key_record != NULL && key_leaf != NULL) {
root = delete_entry(root, key_leaf, key, key_record);
free(key_record);
}
return root;
}
void destroy_tree_nodes(node * root) {
int i;
if (root->is_leaf)
for (i = 0; i < root->num_keys; i++)
free(root->pointers[i]);
else
for (i = 0; i < root->num_keys + 1; i++)
destroy_tree_nodes(root->pointers[i]);
free(root->pointers);
free(root->keys);
free(root);
}
node * destroy_tree(node * root) {
destroy_tree_nodes(root);
return NULL;
}
// MAIN
int main( int argc, char ** argv ) {
char * input_file;
FILE * fp;
node * root;
int input, range2;
char instruction;
char license_part;
root = NULL;
verbose_output = false;
if (argc > 1) {
order = atoi(argv[1]);
if (order < MIN_ORDER || order > MAX_ORDER) {
fprintf(stderr, "Invalid order: %d .\n\n", order);
usage_3();
exit(EXIT_FAILURE);
}
}
license_notice();
usage_1();
usage_2();
if (argc > 2) {
input_file = argv[2];
fp = fopen(input_file, "r");
if (fp == NULL) {
perror("Failure to open input file.");
exit(EXIT_FAILURE);
}
while (!feof(fp)) {
fscanf(fp, "%d\n", &input);
root = insert(root, input, input);
}
fclose(fp);
print_tree(root);
}
printf("> ");
while (scanf("%c", &instruction) != EOF) {
switch (instruction) {
case 'd':
scanf("%d", &input);
root = delete(root, input);
print_tree(root);
break;
case 'i':
scanf("%d", &input);
root = insert(root, input, input);
print_tree(root);
break;
case 'f':
case 'p':
scanf("%d", &input);
find_and_print(root, input, instruction == 'p');
break;
case 'r':
scanf("%d %d", &input, &range2);
if (input > range2) {
int tmp = range2;
range2 = input;
input = tmp;
}
find_and_print_range(root, input, range2, instruction == 'p');
break;
case 'l':
print_leaves(root);
break;
case 'q':
while (getchar() != (int)'\n');
return EXIT_SUCCESS;
case 's':
if (scanf("how %c", &license_part) == 0) {
usage_2();
break;
}
switch(license_part) {
case 'w':
print_license(LICENSE_WARRANTEE);
break;
case 'c':
print_license(LICENSE_CONDITIONS);
break;
default:
usage_2();
break;
}
break;
case 't':
print_tree(root);
break;
case 'v':
verbose_output = !verbose_output;
break;
case 'x':
if (root)
root = destroy_tree(root);
print_tree(root);
break;
default:
usage_2();
break;
}
while (getchar() != (int)'\n');
printf("> ");
}
printf("\n");
return EXIT_SUCCESS;
} B+树实现
最新推荐文章于 2024-05-02 07:35:58 发布
5309
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
