unicorn/glib_compat/gtree.c

1256 lines
32 KiB
C

/* GLIB - Library of useful routines for C programming
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
/*
* Modified by the GLib Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GLib Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GLib at ftp://ftp.gtk.org/pub/gtk/.
*/
/*
* MT safe
*/
#include "gtypes.h"
#include "gtree.h"
//#include "gatomic.h"
//#include "gtestutils.h"
#include "gslice.h"
#include "gmessages.h"
#include "gnode.h"
/**
* SECTION:trees-binary
* @title: Balanced Binary Trees
* @short_description: a sorted collection of key/value pairs optimized
* for searching and traversing in order
*
* The #GTree structure and its associated functions provide a sorted
* collection of key/value pairs optimized for searching and traversing
* in order.
*
* To create a new #GTree use g_tree_new().
*
* To insert a key/value pair into a #GTree use g_tree_insert().
*
* To look up the value corresponding to a given key, use
* g_tree_lookup() and g_tree_lookup_extended().
*
* To find out the number of nodes in a #GTree, use g_tree_nnodes(). To
* get the height of a #GTree, use g_tree_height().
*
* To traverse a #GTree, calling a function for each node visited in
* the traversal, use g_tree_foreach().
*
* To remove a key/value pair use g_tree_remove().
*
* To destroy a #GTree, use g_tree_destroy().
**/
#undef G_TREE_DEBUG
#define MAX_GTREE_HEIGHT 40
typedef struct _GTreeNode GTreeNode;
/**
* GTree:
*
* The GTree struct is an opaque data structure representing a
* [balanced binary tree][glib-Balanced-Binary-Trees]. It should be
* accessed only by using the following functions.
*/
struct _GTree
{
GTreeNode *root;
GCompareDataFunc key_compare;
GDestroyNotify key_destroy_func;
GDestroyNotify value_destroy_func;
gpointer key_compare_data;
guint nnodes;
gint ref_count;
};
struct _GTreeNode
{
gpointer key; /* key for this node */
gpointer value; /* value stored at this node */
GTreeNode *left; /* left subtree */
GTreeNode *right; /* right subtree */
gint8 balance; /* height (right) - height (left) */
guint8 left_child;
guint8 right_child;
};
static GTreeNode* g_tree_node_new (gpointer key,
gpointer value);
static void g_tree_insert_internal (GTree *tree,
gpointer key,
gpointer value,
gboolean replace);
static gboolean g_tree_remove_internal (GTree *tree,
gconstpointer key,
gboolean steal);
static GTreeNode* g_tree_node_balance (GTreeNode *node);
static GTreeNode *g_tree_find_node (GTree *tree,
gconstpointer key);
static gint g_tree_node_pre_order (GTreeNode *node,
GTraverseFunc traverse_func,
gpointer data);
static gint g_tree_node_in_order (GTreeNode *node,
GTraverseFunc traverse_func,
gpointer data);
static gint g_tree_node_post_order (GTreeNode *node,
GTraverseFunc traverse_func,
gpointer data);
static gpointer g_tree_node_search (GTreeNode *node,
GCompareFunc search_func,
gconstpointer data);
static GTreeNode* g_tree_node_rotate_left (GTreeNode *node);
static GTreeNode* g_tree_node_rotate_right (GTreeNode *node);
#ifdef G_TREE_DEBUG
static void g_tree_node_check (GTreeNode *node);
#endif
static GTreeNode *g_tree_node_new (gpointer key, gpointer value)
{
GTreeNode *node = g_slice_new (GTreeNode);
node->balance = 0;
node->left = NULL;
node->right = NULL;
node->left_child = FALSE;
node->right_child = FALSE;
node->key = key;
node->value = value;
return node;
}
/**
* g_tree_new:
* @key_compare_func: the function used to order the nodes in the #GTree.
* It should return values similar to the standard strcmp() function -
* 0 if the two arguments are equal, a negative value if the first argument
* comes before the second, or a positive value if the first argument comes
* after the second.
*
* Creates a new #GTree.
*
* Returns: a newly allocated #GTree
*/
GTree *g_tree_new (GCompareFunc key_compare_func)
{
g_return_val_if_fail (key_compare_func != NULL, NULL);
return g_tree_new_full ((GCompareDataFunc) key_compare_func, NULL,
NULL, NULL);
}
/**
* g_tree_new_with_data:
* @key_compare_func: qsort()-style comparison function
* @key_compare_data: data to pass to comparison function
*
* Creates a new #GTree with a comparison function that accepts user data.
* See g_tree_new() for more details.
*
* Returns: a newly allocated #GTree
*/
GTree *g_tree_new_with_data (GCompareDataFunc key_compare_func, gpointer key_compare_data)
{
g_return_val_if_fail (key_compare_func != NULL, NULL);
return g_tree_new_full (key_compare_func, key_compare_data, NULL, NULL);
}
/**
* g_tree_new_full:
* @key_compare_func: qsort()-style comparison function
* @key_compare_data: data to pass to comparison function
* @key_destroy_func: a function to free the memory allocated for the key
* used when removing the entry from the #GTree or %NULL if you don't
* want to supply such a function
* @value_destroy_func: a function to free the memory allocated for the
* value used when removing the entry from the #GTree or %NULL if you
* don't want to supply such a function
*
* Creates a new #GTree like g_tree_new() and allows to specify functions
* to free the memory allocated for the key and value that get called when
* removing the entry from the #GTree.
*
* Returns: a newly allocated #GTree
*/
GTree *g_tree_new_full (GCompareDataFunc key_compare_func,
gpointer key_compare_data,
GDestroyNotify key_destroy_func,
GDestroyNotify value_destroy_func)
{
GTree *tree;
g_return_val_if_fail (key_compare_func != NULL, NULL);
tree = g_slice_new (GTree);
tree->root = NULL;
tree->key_compare = key_compare_func;
tree->key_destroy_func = key_destroy_func;
tree->value_destroy_func = value_destroy_func;
tree->key_compare_data = key_compare_data;
tree->nnodes = 0;
tree->ref_count = 1;
return tree;
}
static inline GTreeNode *g_tree_first_node (GTree *tree)
{
GTreeNode *tmp;
if (!tree->root)
return NULL;
tmp = tree->root;
while (tmp->left_child)
tmp = tmp->left;
return tmp;
}
static inline GTreeNode *g_tree_node_previous (GTreeNode *node)
{
GTreeNode *tmp;
tmp = node->left;
if (node->left_child)
while (tmp->right_child)
tmp = tmp->right;
return tmp;
}
static inline GTreeNode *g_tree_node_next (GTreeNode *node)
{
GTreeNode *tmp;
tmp = node->right;
if (node->right_child)
while (tmp->left_child)
tmp = tmp->left;
return tmp;
}
void g_tree_remove_all (GTree *tree)
{
GTreeNode *node;
GTreeNode *next;
g_return_if_fail (tree != NULL);
node = g_tree_first_node (tree);
while (node)
{
next = g_tree_node_next (node);
if (tree->key_destroy_func)
tree->key_destroy_func (node->key);
if (tree->value_destroy_func)
tree->value_destroy_func (node->value);
g_slice_free (GTreeNode, node);
node = next;
}
tree->root = NULL;
tree->nnodes = 0;
}
/**
* g_tree_ref:
* @tree: a #GTree
*
* Increments the reference count of @tree by one.
*
* It is safe to call this function from any thread.
*
* Returns: the passed in #GTree
*
* Since: 2.22
*/
GTree *g_tree_ref (GTree *tree)
{
g_return_val_if_fail (tree != NULL, NULL);
tree->ref_count++;
return tree;
}
/**
* g_tree_unref:
* @tree: a #GTree
*
* Decrements the reference count of @tree by one.
* If the reference count drops to 0, all keys and values will
* be destroyed (if destroy functions were specified) and all
* memory allocated by @tree will be released.
*
* It is safe to call this function from any thread.
*
* Since: 2.22
*/
void g_tree_unref (GTree *tree)
{
g_return_if_fail (tree != NULL);
tree->ref_count--;
if (!tree->ref_count)
{
g_tree_remove_all (tree);
g_slice_free (GTree, tree);
}
}
/**
* g_tree_destroy:
* @tree: a #GTree
*
* Removes all keys and values from the #GTree and decreases its
* reference count by one. If keys and/or values are dynamically
* allocated, you should either free them first or create the #GTree
* using g_tree_new_full(). In the latter case the destroy functions
* you supplied will be called on all keys and values before destroying
* the #GTree.
*/
void g_tree_destroy (GTree *tree)
{
g_return_if_fail (tree != NULL);
g_tree_remove_all (tree);
g_tree_unref (tree);
}
/**
* g_tree_insert:
* @tree: a #GTree
* @key: the key to insert
* @value: the value corresponding to the key
*
* Inserts a key/value pair into a #GTree.
*
* If the given key already exists in the #GTree its corresponding value
* is set to the new value. If you supplied a @value_destroy_func when
* creating the #GTree, the old value is freed using that function. If
* you supplied a @key_destroy_func when creating the #GTree, the passed
* key is freed using that function.
*
* The tree is automatically 'balanced' as new key/value pairs are added,
* so that the distance from the root to every leaf is as small as possible.
*/
void g_tree_insert (GTree *tree, gpointer key, gpointer value)
{
g_return_if_fail (tree != NULL);
g_tree_insert_internal (tree, key, value, FALSE);
#ifdef G_TREE_DEBUG
g_tree_node_check (tree->root);
#endif
}
/**
* g_tree_replace:
* @tree: a #GTree
* @key: the key to insert
* @value: the value corresponding to the key
*
* Inserts a new key and value into a #GTree similar to g_tree_insert().
* The difference is that if the key already exists in the #GTree, it gets
* replaced by the new key. If you supplied a @value_destroy_func when
* creating the #GTree, the old value is freed using that function. If you
* supplied a @key_destroy_func when creating the #GTree, the old key is
* freed using that function.
*
* The tree is automatically 'balanced' as new key/value pairs are added,
* so that the distance from the root to every leaf is as small as possible.
*/
void g_tree_replace (GTree *tree, gpointer key, gpointer value)
{
g_return_if_fail (tree != NULL);
g_tree_insert_internal (tree, key, value, TRUE);
#ifdef G_TREE_DEBUG
g_tree_node_check (tree->root);
#endif
}
/* internal insert routine */
static void g_tree_insert_internal (GTree *tree, gpointer key, gpointer value, gboolean replace)
{
GTreeNode *node;
GTreeNode *path[MAX_GTREE_HEIGHT];
int idx;
g_return_if_fail (tree != NULL);
if (!tree->root)
{
tree->root = g_tree_node_new (key, value);
tree->nnodes++;
return;
}
idx = 0;
path[idx++] = NULL;
node = tree->root;
while (1)
{
int cmp = tree->key_compare (key, node->key, tree->key_compare_data);
if (cmp == 0)
{
if (tree->value_destroy_func)
tree->value_destroy_func (node->value);
node->value = value;
if (replace)
{
if (tree->key_destroy_func)
tree->key_destroy_func (node->key);
node->key = key;
}
else
{
/* free the passed key */
if (tree->key_destroy_func)
tree->key_destroy_func (key);
}
return;
}
else if (cmp < 0)
{
if (node->left_child)
{
path[idx++] = node;
node = node->left;
}
else
{
GTreeNode *child = g_tree_node_new (key, value);
child->left = node->left;
child->right = node;
node->left = child;
node->left_child = TRUE;
node->balance -= 1;
tree->nnodes++;
break;
}
}
else
{
if (node->right_child)
{
path[idx++] = node;
node = node->right;
}
else
{
GTreeNode *child = g_tree_node_new (key, value);
child->right = node->right;
child->left = node;
node->right = child;
node->right_child = TRUE;
node->balance += 1;
tree->nnodes++;
break;
}
}
}
/* Restore balance. This is the goodness of a non-recursive
* implementation, when we are done with balancing we 'break'
* the loop and we are done.
*/
while (1)
{
GTreeNode *bparent = path[--idx];
gboolean left_node = (bparent && node == bparent->left);
//g_assert (!bparent || bparent->left == node || bparent->right == node);
if (node->balance < -1 || node->balance > 1)
{
node = g_tree_node_balance (node);
if (bparent == NULL)
tree->root = node;
else if (left_node)
bparent->left = node;
else
bparent->right = node;
}
if (node->balance == 0 || bparent == NULL)
break;
if (left_node)
bparent->balance -= 1;
else
bparent->balance += 1;
node = bparent;
}
}
/**
* g_tree_remove:
* @tree: a #GTree
* @key: the key to remove
*
* Removes a key/value pair from a #GTree.
*
* If the #GTree was created using g_tree_new_full(), the key and value
* are freed using the supplied destroy functions, otherwise you have to
* make sure that any dynamically allocated values are freed yourself.
* If the key does not exist in the #GTree, the function does nothing.
*
* Returns: %TRUE if the key was found (prior to 2.8, this function
* returned nothing)
*/
gboolean g_tree_remove (GTree *tree, gconstpointer key)
{
gboolean removed;
g_return_val_if_fail (tree != NULL, FALSE);
removed = g_tree_remove_internal (tree, key, FALSE);
#ifdef G_TREE_DEBUG
g_tree_node_check (tree->root);
#endif
return removed;
}
/**
* g_tree_steal:
* @tree: a #GTree
* @key: the key to remove
*
* Removes a key and its associated value from a #GTree without calling
* the key and value destroy functions.
*
* If the key does not exist in the #GTree, the function does nothing.
*
* Returns: %TRUE if the key was found (prior to 2.8, this function
* returned nothing)
*/
gboolean g_tree_steal (GTree *tree, gconstpointer key)
{
gboolean removed;
g_return_val_if_fail (tree != NULL, FALSE);
removed = g_tree_remove_internal (tree, key, TRUE);
#ifdef G_TREE_DEBUG
g_tree_node_check (tree->root);
#endif
return removed;
}
/* internal remove routine */
static gboolean g_tree_remove_internal (GTree *tree, gconstpointer key, gboolean steal)
{
GTreeNode *node, *parent, *balance;
GTreeNode *path[MAX_GTREE_HEIGHT];
int idx;
gboolean left_node;
g_return_val_if_fail (tree != NULL, FALSE);
if (!tree->root)
return FALSE;
idx = 0;
path[idx++] = NULL;
node = tree->root;
while (1)
{
int cmp = tree->key_compare (key, node->key, tree->key_compare_data);
if (cmp == 0)
break;
else if (cmp < 0)
{
if (!node->left_child)
return FALSE;
path[idx++] = node;
node = node->left;
}
else
{
if (!node->right_child)
return FALSE;
path[idx++] = node;
node = node->right;
}
}
/* The following code is almost equal to g_tree_remove_node,
* except that we do not have to call g_tree_node_parent.
*/
balance = parent = path[--idx];
//g_assert (!parent || parent->left == node || parent->right == node);
left_node = (parent && node == parent->left);
if (!node->left_child)
{
if (!node->right_child)
{
if (!parent)
tree->root = NULL;
else if (left_node)
{
parent->left_child = FALSE;
parent->left = node->left;
parent->balance += 1;
}
else
{
parent->right_child = FALSE;
parent->right = node->right;
parent->balance -= 1;
}
}
else /* node has a right child */
{
GTreeNode *tmp = g_tree_node_next (node);
tmp->left = node->left;
if (!parent)
tree->root = node->right;
else if (left_node)
{
parent->left = node->right;
parent->balance += 1;
}
else
{
parent->right = node->right;
parent->balance -= 1;
}
}
}
else /* node has a left child */
{
if (!node->right_child)
{
GTreeNode *tmp = g_tree_node_previous (node);
tmp->right = node->right;
if (parent == NULL)
tree->root = node->left;
else if (left_node)
{
parent->left = node->left;
parent->balance += 1;
}
else
{
parent->right = node->left;
parent->balance -= 1;
}
}
else /* node has a both children (pant, pant!) */
{
GTreeNode *prev = node->left;
GTreeNode *next = node->right;
GTreeNode *nextp = node;
int old_idx = idx + 1;
idx++;
/* path[idx] == parent */
/* find the immediately next node (and its parent) */
while (next->left_child)
{
path[++idx] = nextp = next;
next = next->left;
}
path[old_idx] = next;
balance = path[idx];
/* remove 'next' from the tree */
if (nextp != node)
{
if (next->right_child)
nextp->left = next->right;
else
nextp->left_child = FALSE;
nextp->balance += 1;
next->right_child = TRUE;
next->right = node->right;
}
else
node->balance -= 1;
/* set the prev to point to the right place */
while (prev->right_child)
prev = prev->right;
prev->right = next;
/* prepare 'next' to replace 'node' */
next->left_child = TRUE;
next->left = node->left;
next->balance = node->balance;
if (!parent)
tree->root = next;
else if (left_node)
parent->left = next;
else
parent->right = next;
}
}
/* restore balance */
if (balance)
while (1)
{
GTreeNode *bparent = path[--idx];
//g_assert (!bparent || bparent->left == balance || bparent->right == balance);
left_node = (bparent && balance == bparent->left);
if(balance->balance < -1 || balance->balance > 1)
{
balance = g_tree_node_balance (balance);
if (!bparent)
tree->root = balance;
else if (left_node)
bparent->left = balance;
else
bparent->right = balance;
}
if (balance->balance != 0 || !bparent)
break;
if (left_node)
bparent->balance += 1;
else
bparent->balance -= 1;
balance = bparent;
}
if (!steal)
{
if (tree->key_destroy_func)
tree->key_destroy_func (node->key);
if (tree->value_destroy_func)
tree->value_destroy_func (node->value);
}
g_slice_free (GTreeNode, node);
tree->nnodes--;
return TRUE;
}
/**
* g_tree_lookup:
* @tree: a #GTree
* @key: the key to look up
*
* Gets the value corresponding to the given key. Since a #GTree is
* automatically balanced as key/value pairs are added, key lookup
* is O(log n) (where n is the number of key/value pairs in the tree).
*
* Returns: the value corresponding to the key, or %NULL
* if the key was not found
*/
gpointer g_tree_lookup (GTree *tree, gconstpointer key)
{
GTreeNode *node;
g_return_val_if_fail (tree != NULL, NULL);
node = g_tree_find_node (tree, key);
return node ? node->value : NULL;
}
/**
* g_tree_lookup_extended:
* @tree: a #GTree
* @lookup_key: the key to look up
* @orig_key: (out) (optional) (nullable): returns the original key
* @value: (out) (optional) (nullable): returns the value associated with the key
*
* Looks up a key in the #GTree, returning the original key and the
* associated value. This is useful if you need to free the memory
* allocated for the original key, for example before calling
* g_tree_remove().
*
* Returns: %TRUE if the key was found in the #GTree
*/
gboolean g_tree_lookup_extended (GTree *tree,
gconstpointer lookup_key,
gpointer *orig_key,
gpointer *value)
{
GTreeNode *node;
g_return_val_if_fail (tree != NULL, FALSE);
node = g_tree_find_node (tree, lookup_key);
if (node)
{
if (orig_key)
*orig_key = node->key;
if (value)
*value = node->value;
return TRUE;
}
else
return FALSE;
}
/**
* g_tree_foreach:
* @tree: a #GTree
* @func: the function to call for each node visited.
* If this function returns %TRUE, the traversal is stopped.
* @user_data: user data to pass to the function
*
* Calls the given function for each of the key/value pairs in the #GTree.
* The function is passed the key and value of each pair, and the given
* @data parameter. The tree is traversed in sorted order.
*
* The tree may not be modified while iterating over it (you can't
* add/remove items). To remove all items matching a predicate, you need
* to add each item to a list in your #GTraverseFunc as you walk over
* the tree, then walk the list and remove each item.
*/
void g_tree_foreach (GTree *tree, GTraverseFunc func, gpointer user_data)
{
GTreeNode *node;
g_return_if_fail (tree != NULL);
if (!tree->root)
return;
node = g_tree_first_node (tree);
while (node)
{
if ((*func) (node->key, node->value, user_data))
break;
node = g_tree_node_next (node);
}
}
/**
* g_tree_traverse:
* @tree: a #GTree
* @traverse_func: the function to call for each node visited. If this
* function returns %TRUE, the traversal is stopped.
* @traverse_type: the order in which nodes are visited, one of %G_IN_ORDER,
* %G_PRE_ORDER and %G_POST_ORDER
* @user_data: user data to pass to the function
*
* Calls the given function for each node in the #GTree.
*
* Deprecated:2.2: The order of a balanced tree is somewhat arbitrary.
* If you just want to visit all nodes in sorted order, use
* g_tree_foreach() instead. If you really need to visit nodes in
* a different order, consider using an [n-ary tree][glib-N-ary-Trees].
*/
/**
* GTraverseFunc:
* @key: a key of a #GTree node
* @value: the value corresponding to the key
* @data: user data passed to g_tree_traverse()
*
* Specifies the type of function passed to g_tree_traverse(). It is
* passed the key and value of each node, together with the @user_data
* parameter passed to g_tree_traverse(). If the function returns
* %TRUE, the traversal is stopped.
*
* Returns: %TRUE to stop the traversal
*/
void g_tree_traverse (GTree *tree,
GTraverseFunc traverse_func,
GTraverseType traverse_type,
gpointer user_data)
{
g_return_if_fail (tree != NULL);
if (!tree->root)
return;
switch (traverse_type)
{
case G_PRE_ORDER:
g_tree_node_pre_order (tree->root, traverse_func, user_data);
break;
case G_IN_ORDER:
g_tree_node_in_order (tree->root, traverse_func, user_data);
break;
case G_POST_ORDER:
g_tree_node_post_order (tree->root, traverse_func, user_data);
break;
case G_LEVEL_ORDER:
//g_warning ("g_tree_traverse(): traverse type G_LEVEL_ORDER isn't implemented.");
break;
}
}
/**
* g_tree_search:
* @tree: a #GTree
* @search_func: a function used to search the #GTree
* @user_data: the data passed as the second argument to @search_func
*
* Searches a #GTree using @search_func.
*
* The @search_func is called with a pointer to the key of a key/value
* pair in the tree, and the passed in @user_data. If @search_func returns
* 0 for a key/value pair, then the corresponding value is returned as
* the result of g_tree_search(). If @search_func returns -1, searching
* will proceed among the key/value pairs that have a smaller key; if
* @search_func returns 1, searching will proceed among the key/value
* pairs that have a larger key.
*
* Returns: the value corresponding to the found key, or %NULL
* if the key was not found
*/
gpointer g_tree_search (GTree *tree,
GCompareFunc search_func,
gconstpointer user_data)
{
g_return_val_if_fail (tree != NULL, NULL);
if (tree->root)
return g_tree_node_search (tree->root, search_func, user_data);
else
return NULL;
}
/**
* g_tree_height:
* @tree: a #GTree
*
* Gets the height of a #GTree.
*
* If the #GTree contains no nodes, the height is 0.
* If the #GTree contains only one root node the height is 1.
* If the root node has children the height is 2, etc.
*
* Returns: the height of @tree
*/
gint g_tree_height (GTree *tree)
{
GTreeNode *node;
gint height;
g_return_val_if_fail (tree != NULL, 0);
if (!tree->root)
return 0;
height = 0;
node = tree->root;
while (1)
{
height += 1 + MAX(node->balance, 0);
if (!node->left_child)
return height;
node = node->left;
}
}
/**
* g_tree_nnodes:
* @tree: a #GTree
*
* Gets the number of nodes in a #GTree.
*
* Returns: the number of nodes in @tree
*/
gint g_tree_nnodes (GTree *tree)
{
g_return_val_if_fail (tree != NULL, 0);
return tree->nnodes;
}
static GTreeNode *g_tree_node_balance (GTreeNode *node)
{
if (node->balance < -1)
{
if (node->left->balance > 0)
node->left = g_tree_node_rotate_left (node->left);
node = g_tree_node_rotate_right (node);
}
else if (node->balance > 1)
{
if (node->right->balance < 0)
node->right = g_tree_node_rotate_right (node->right);
node = g_tree_node_rotate_left (node);
}
return node;
}
static GTreeNode *g_tree_find_node (GTree *tree, gconstpointer key)
{
GTreeNode *node;
gint cmp;
node = tree->root;
if (!node)
return NULL;
while (1)
{
cmp = tree->key_compare (key, node->key, tree->key_compare_data);
if (cmp == 0)
return node;
else if (cmp < 0)
{
if (!node->left_child)
return NULL;
node = node->left;
}
else
{
if (!node->right_child)
return NULL;
node = node->right;
}
}
}
static gint g_tree_node_pre_order (GTreeNode *node, GTraverseFunc traverse_func, gpointer data)
{
if ((*traverse_func) (node->key, node->value, data))
return TRUE;
if (node->left_child)
{
if (g_tree_node_pre_order (node->left, traverse_func, data))
return TRUE;
}
if (node->right_child)
{
if (g_tree_node_pre_order (node->right, traverse_func, data))
return TRUE;
}
return FALSE;
}
static gint g_tree_node_in_order (GTreeNode *node, GTraverseFunc traverse_func, gpointer data)
{
if (node->left_child)
{
if (g_tree_node_in_order (node->left, traverse_func, data))
return TRUE;
}
if ((*traverse_func) (node->key, node->value, data))
return TRUE;
if (node->right_child)
{
if (g_tree_node_in_order (node->right, traverse_func, data))
return TRUE;
}
return FALSE;
}
static gint g_tree_node_post_order (GTreeNode *node,
GTraverseFunc traverse_func,
gpointer data)
{
if (node->left_child)
{
if (g_tree_node_post_order (node->left, traverse_func, data))
return TRUE;
}
if (node->right_child)
{
if (g_tree_node_post_order (node->right, traverse_func, data))
return TRUE;
}
if ((*traverse_func) (node->key, node->value, data))
return TRUE;
return FALSE;
}
static gpointer g_tree_node_search (GTreeNode *node,
GCompareFunc search_func,
gconstpointer data)
{
gint dir;
if (!node)
return NULL;
while (1)
{
dir = (* search_func) (node->key, data);
if (dir == 0)
return node->value;
else if (dir < 0)
{
if (!node->left_child)
return NULL;
node = node->left;
}
else
{
if (!node->right_child)
return NULL;
node = node->right;
}
}
}
static GTreeNode *g_tree_node_rotate_left (GTreeNode *node)
{
GTreeNode *right;
gint a_bal;
gint b_bal;
right = node->right;
if (right->left_child)
node->right = right->left;
else
{
node->right_child = FALSE;
right->left_child = TRUE;
}
right->left = node;
a_bal = node->balance;
b_bal = right->balance;
if (b_bal <= 0)
{
if (a_bal >= 1)
right->balance = b_bal - 1;
else
right->balance = a_bal + b_bal - 2;
node->balance = a_bal - 1;
}
else
{
if (a_bal <= b_bal)
right->balance = a_bal - 2;
else
right->balance = b_bal - 1;
node->balance = a_bal - b_bal - 1;
}
return right;
}
static GTreeNode *g_tree_node_rotate_right (GTreeNode *node)
{
GTreeNode *left;
gint a_bal;
gint b_bal;
left = node->left;
if (left->right_child)
node->left = left->right;
else
{
node->left_child = FALSE;
left->right_child = TRUE;
}
left->right = node;
a_bal = node->balance;
b_bal = left->balance;
if (b_bal <= 0)
{
if (b_bal > a_bal)
left->balance = b_bal + 1;
else
left->balance = a_bal + 2;
node->balance = a_bal - b_bal + 1;
}
else
{
if (a_bal <= -1)
left->balance = b_bal + 1;
else
left->balance = a_bal + b_bal + 2;
node->balance = a_bal + 1;
}
return left;
}