Searching with different variables in a Binary Search Tree - c

Question

I have a binary search tree which stores ID, name and other details of a person and insertion is based on the id.
struct tree_node {
int ID;
char name[32];
char city[16];
struct tree_node* left_node;
struct tree_node* right_node;
}
This tree uses ID for insertion and searching and deletion and update. What if I want to add an option that all the above operation can be based on name or city. I will have to create a new tree for every attribute. Is there an alternative method to do?

Answer 1

A separate tree is required for each key. To reduce the amount of code required, the tree control parts can be separated out as members of a common struct type:
struct tree_node {
struct tree_node *left;
struct tree_node *right;
};
struct zone {
int ID;
char name[32];
char city[16];
struct tree_node id_node;
struct tree_node name_node;
struct tree_node city_node;
};
Then some functions can be defined to convert pointers to the id_node, name_node and city_node members to their containing struct zone. These make use of a simplified version of the container_of() macro from Linux:
#include <stddef.h>
#define container_of(ptr, type, member) \
((type *)((char *)(ptr) - offsetof(type, member)))
static inline struct zone *
struct_zone_from_id_node(const struct tree_node *id_node_p)
{
return container_of(id_node_p, struct zone, id_node);
}
static inline struct zone *
struct_zone_from_name_node(const struct tree_node *name_node_p)
{
return container_of(name_node_p, struct zone, name_node);
}
static inline struct zone *
struct_zone_from_city_node(const struct tree_node *city_node_p)
{
return container_of(city_node_p, struct zone, city_node);
}
It will be useful to define a function to clear the linkage of a struct tree_node before inserting it into a tree or after removing it from a tree:
static inline void tree_node_clear(struct tree_node *node)
{
node->left = NULL;
node->right = NULL;
}
The trees for each key will need their own root node pointers:
struct tree_node *id_root = NULL;
struct tree_node *name_root = NULL;
struct tree_node *city_root = NULL;
For convenience, define functions to return the ID from the containing struct zone of a node of the "ID" tree, to return a pointer to the name member in the containing struct zone of a node of the "name" tree, and to return a pointer to the city member in the containing struct zone of a node of the "city" tree:
static inline int id_from_id_node(const struct tree_node *id_node_p)
{
return struct_zone_from_id_node(id_node_p)->ID;
}
static inline char *
name_from_name_node(const struct tree_node *name_node_p)
{
return struct_zone_from_name_node(name_node_p)->name;
}
static inline char *
city_from_city_node(const struct tree_node *city_node_p)
{
return struct_zone_from_city_node(city_node_p)->city;
}
Some functions for comparing IDs, names and cities can be defined. For example:
#include <string.h>
static int cmp_id(int id_a, int id_b)
{
return (id_a > id_b) - (id_a < id_b);
}
static int cmp_name(const char *name_a, const char *name_b)
{
return strcmp(name_a, name_b);
}
static int cmp_city(const char *city_a, const char *city_b)
{
return strcmp(city_a, city_b);
}
Those functions can be used in the definitions of functions for comparing nodes of the "ID", "name" and "city" trees:
static int tree_cmp_id(const struct tree_node *id_node_a,
const struct tree_node *id_node_b)
{
int id_a = id_from_id_node(id_node_a);
int id_b = id_from_id_node(id_node_b);
return cmp_id(id_a, id_b);
}
static int tree_cmp_name(const struct tree_node *name_node_a,
const struct tree_node *name_node_b)
{
const char *name_a = name_from_name_node(name_node_a);
const char *name_b = name_from_name_node(name_node_b);
return cmp_name(name_a, name_b);
}
static int tree_cmp_city(const struct tree_node *city_node_a,
const struct tree_node *city_node_b)
{
const char *city_a = city_from_city_node(city_node_a);
const char *city_b = city_from_city_node(city_node_b);
return cmp_city(city_a, city_b);
}
Some of the generic tree node handling functions will need a parameter that points to a function for comparing two nodes. The type of the function pointer can be defined as a typedef name:
typedef int (*tree_node_cmp_fn)(const struct tree_node *,
const struct tree_node *);
For example, the generic tree function for inserting a struct tree_node might have a prototype like the following (using a pointer to a pointer to the root node for functions that modify the tree):
int tree_insert(struct tree_node **root, struct tree_node *node,
tree_node_cmp_fn cmp);
Here is a possible implementation of tree_insert(). It returns 0 if the node was added successfully, or -1 if a node with a matching key already exists in the tree (and it also sets errno to EEXIST in that case):
#include <errno.h>
int tree_insert(struct tree_node **root, struct tree_node *node,
tree_node_cmp_fn cmp)
{
int found = 0;
while (!found && *root != NULL) {
int c = cmp(node, *root);
if (c < 0) {
root = &(*root)->left;
} else if (c > 0) {
root = &(*root)->right;
} else {
/* A node with a matching key already exists. */
found = -1;
}
}
if (found) {
/* Set an error if a node with a matching key already exists. */
errno = EEXIST;
} else {
/*
* *root will be NULL.
* Clear new node's linkage and append it to the tree.
*/
tree_node_clear(node);
*root = node;
}
return found;
}
The tree_insert() function can be called with the appropriate comparision functions in the definitions of functions for inserting a struct zone into the "ID" tree, the "name" tree, or the "city" tree:
int id_tree_insert(struct tree_node **id_root, struct zone *zone)
{
return tree_insert(id_root, &zone->id_node, tree_cmp_id);
}
int name_tree_insert(struct tree_node **name_root, struct zone *zone)
{
return tree_insert(name_root, &zone->name_node, tree_cmp_name);
}
int city_tree_insert(struct tree_node **city_root, struct zone *zone)
{
return tree_insert(city_root, &zone->city_node, tree_cmp_city);
}
Functions for searching the "ID", "name" and "city" trees follow a similar pattern to each other, but using a generic tree search function is not very practical:
struct zone *id_tree_find(struct tree_node *id_root, int id)
{
struct zone *result = NULL;
while (result == NULL && id_root != NULL) {
struct zone *cur_zone = struct_zone_from_id_node(id_root);
int cmp = cmp_id(id, cur_zone->ID);
if (cmp < 0) {
id_root = id_root->left;
} else if (cmp > 0) {
id_root = id_root->right;
} else {
result = cur_zone;
}
}
return result;
}
struct zone *name_tree_find(struct tree_node *id_root, const char *name)
{
struct zone *result = NULL;
while (result == NULL && id_root != NULL) {
struct zone *cur_zone = struct_zone_from_name_node(id_root);
int cmp = cmp_name(name, cur_zone->name);
if (cmp < 0) {
id_root = id_root->left;
} else if (cmp > 0) {
id_root = id_root->right;
} else {
result = cur_zone;
}
}
return result;
}
struct zone *city_tree_find(struct tree_node *id_root, const char *city)
{
struct zone *result = NULL;
while (result == NULL && id_root != NULL) {
struct zone *cur_zone = struct_zone_from_city_node(id_root);
int cmp = cmp_city(city, cur_zone->city);
if (cmp < 0) {
id_root = id_root->left;
} else if (cmp > 0) {
id_root = id_root->right;
} else {
result = cur_zone;
}
}
return result;
}
Because the functions are so similar, a macro could be defined to define the functions. This makes use of the container_of() macro defined earlier:
#define DEFINE_TREE_FIND(fn_name, root, container_type, member, \
val_type, val, cmp_fn) \
container_type *fn_name(struct tree_node *root, val_type val) \
{ \
container_type *_result = NULL; \
while (_result == NULL && root != NULL) { \
container_type *_current = \
container_of(root, container_type, member); \
int _cmp = cmp_fn(val, _current->member); \
if (_cmp < 0) { \
root = root->left; \
} else if (_cmp > 0) { \
root = root->right; \
} else { \
_result = _current; \
} \
} \
return _result; \
}
#define DEFINE_TREE_FIND_ZONE(fn_name, root, member, \
val_type, val, cmp_fn) \
DEFINE_TREE_FIND(fn_name, root, struct zone, member, \
val_type, val, cmp_fn)
(The DEFINE_TREE_FIND_ZONE() macro is specific to defining functions that find a struct zone, but the DEFINE_TREE_FIND() macro is more general and can be used to define functions for finding any container type that includes a struct tree_node member.)
Then the searching functions can be defined by calling the DEFINE_TREE_FIND_ZONE() macro outside any functions (I have appended 2 to the function names to distinguish them from the previously defined search functions):
DEFINE_TREE_FIND_ZONE(id_tree_find2, id_root, ID, int, id, cmp_id)
DEFINE_TREE_FIND_ZONE(name_tree_find2, name_root, name,
const char *, name, cmp_name)
DEFINE_TREE_FIND_ZONE(city_tree_find2, city_root, city,
const char *, city, cmp_city)
For completeness, define a generic function to remove a node from a tree. Here is a function prototype:
int tree_remove(struct tree_node **root, struct tree_node *node,
tree_node_cmp_fn cmp);
Here is an implementation to tree_remove(). It returns 0 if the node was found and removed. It returns -1 and sets errno to ENOENT if no node that matched the node's key was found, or sets errno to EEXIST if a different node with the node's key was found:
int tree_remove(struct tree_node **root, struct tree_node *node,
tree_node_cmp_fn cmp)
{
int not_found = -1;
while (not_found && *root != NULL) {
int c = cmp(node, *root);
if (c < 0) {
root = &(*root)->left;
} else if (c > 0) {
root = &(*root)->right;
} else {
/* Found! */
not_found = 0;
}
}
if (not_found) {
/* Set an error if a node is not in the tree. */
errno = ENOENT;
} else if (*root != node) {
/* Found a different node with the same key! Set an error. */
not_found = -1;
errno = EEXIST;
} else {
/* Found the correct node, so remove it. */
if ((*root)->left == NULL) {
/* No left node, so replace *root with right node (if any). */
*root = (*root)->right;
} else if ((*root)->right == NULL) {
/* No right node, so replace *root with left node (if any). */
*root = (*root)->left;
} else {
/* Find the right-most node on the left sub-tree. */
struct tree_node **link = &(*root)->left;
struct tree_node *move;
while ((*link)->right != NULL) {
link = &(*link)->right;
}
/* Move *link to the position of the removed node. */
move = *link;
*link = move->left;
move->left = (*root)->left;
move->right = (*root)->right;
*root = move;
/* Clear removed node's linkage. */
tree_node_clear(node);
/* Clear removed node's linkage. */
tree_node_clear(node);
}
}
return not_found;
}
The tree_remove() function can be called with the appropriate comparision functions in the definitions of functions for removing a struct zone from the "ID" tree, the "name" tree, or the "city" tree:
int id_tree_remove(struct tree_node **id_root, struct zone *zone)
{
return tree_remove(id_root, &zone->id_node, tree_cmp_id);
}
int name_tree_remove(struct tree_node **name_root, struct zone *zone)
{
return tree_remove(name_root, &zone->name_node, tree_cmp_name);
}
int city_tree_remove(struct tree_node **city_root, struct zone *zone)
{
return tree_remove(city_root, &zone->city_node, tree_cmp_city);
}
If the struct zone was allocated dynamically, the caller can free it once it has been removed from all the trees it is attached to.