#include "rotatingtree.h" | |
#define KEY_LOWER_THAN(key1, key2) ((char*)(key1) < (char*)(key2)) | |
/* The randombits() function below is a fast-and-dirty generator that | |
* is probably irregular enough for our purposes. Note that it's biased: | |
* I think that ones are slightly more probable than zeroes. It's not | |
* important here, though. | |
*/ | |
static unsigned int random_value = 1; | |
static unsigned int random_stream = 0; | |
static int | |
randombits(int bits) | |
{ | |
int result; | |
if (random_stream < (1U << bits)) { | |
random_value *= 1082527; | |
random_stream = random_value; | |
} | |
result = random_stream & ((1<<bits)-1); | |
random_stream >>= bits; | |
return result; | |
} | |
/* Insert a new node into the tree. | |
(*root) is modified to point to the new root. */ | |
void | |
RotatingTree_Add(rotating_node_t **root, rotating_node_t *node) | |
{ | |
while (*root != NULL) { | |
if (KEY_LOWER_THAN(node->key, (*root)->key)) | |
root = &((*root)->left); | |
else | |
root = &((*root)->right); | |
} | |
node->left = NULL; | |
node->right = NULL; | |
*root = node; | |
} | |
/* Locate the node with the given key. This is the most complicated | |
function because it occasionally rebalances the tree to move the | |
resulting node closer to the root. */ | |
rotating_node_t * | |
RotatingTree_Get(rotating_node_t **root, void *key) | |
{ | |
if (randombits(3) != 4) { | |
/* Fast path, no rebalancing */ | |
rotating_node_t *node = *root; | |
while (node != NULL) { | |
if (node->key == key) | |
return node; | |
if (KEY_LOWER_THAN(key, node->key)) | |
node = node->left; | |
else | |
node = node->right; | |
} | |
return NULL; | |
} | |
else { | |
rotating_node_t **pnode = root; | |
rotating_node_t *node = *pnode; | |
rotating_node_t *next; | |
int rotate; | |
if (node == NULL) | |
return NULL; | |
while (1) { | |
if (node->key == key) | |
return node; | |
rotate = !randombits(1); | |
if (KEY_LOWER_THAN(key, node->key)) { | |
next = node->left; | |
if (next == NULL) | |
return NULL; | |
if (rotate) { | |
node->left = next->right; | |
next->right = node; | |
*pnode = next; | |
} | |
else | |
pnode = &(node->left); | |
} | |
else { | |
next = node->right; | |
if (next == NULL) | |
return NULL; | |
if (rotate) { | |
node->right = next->left; | |
next->left = node; | |
*pnode = next; | |
} | |
else | |
pnode = &(node->right); | |
} | |
node = next; | |
} | |
} | |
} | |
/* Enumerate all nodes in the tree. The callback enumfn() should return | |
zero to continue the enumeration, or non-zero to interrupt it. | |
A non-zero value is directly returned by RotatingTree_Enum(). */ | |
int | |
RotatingTree_Enum(rotating_node_t *root, rotating_tree_enum_fn enumfn, | |
void *arg) | |
{ | |
int result; | |
rotating_node_t *node; | |
while (root != NULL) { | |
result = RotatingTree_Enum(root->left, enumfn, arg); | |
if (result != 0) return result; | |
node = root->right; | |
result = enumfn(root, arg); | |
if (result != 0) return result; | |
root = node; | |
} | |
return 0; | |
} |