#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 intrandombits(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. */voidRotatingTree_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(). */intRotatingTree_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;}