diff options
Diffstat (limited to 'misc/tsearch.c')
| -rw-r--r-- | misc/tsearch.c | 215 |
1 files changed, 215 insertions, 0 deletions
diff --git a/misc/tsearch.c b/misc/tsearch.c new file mode 100644 index 0000000000..cb06b7d8c8 --- /dev/null +++ b/misc/tsearch.c @@ -0,0 +1,215 @@ +/* Copyright (C) 1995 Free Software Foundation, Inc. +This file is part of the GNU C Library. + +The GNU C Library is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public License as +published by the Free Software Foundation; either version 2 of the +License, or (at your option) any later version. + +The GNU C 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with the GNU C Library; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +/* Tree search generalized from Knuth (6.2.2) Algorithm T just like + the AT&T man page says. + + The node_t structure is for internal use only, lint doesn't grok it. + + Written by reading the System V Interface Definition, not the code. + + Totally public domain. */ +/*LINTLIBRARY*/ + +#include <stdlib.h> +#include <search.h> + +/* This routine is not very bad. It makes many assumptions about + the compiler. It assumpts that the first field in node must be + the "key" field, which points to the datum. It is a very trick + stuff. H.J. */ + +typedef struct node_t +{ + const void *key; + struct node_t *left; + struct node_t *right; +} +node; + +/* Prototype fpr local function. */ +static void trecurse __P ((const void *vroot, __action_fn_t action, int level)); + + +/* find or insert datum into search tree. +char *key; key to be located +node **rootp; address of tree root +int (*compar)(); ordering function +*/ +void * +tsearch (key, vrootp, compar) + const void *key; + void **vrootp; + __compar_fn_t compar; +{ + node *q; + node **rootp = (node **) vrootp; + + if (rootp == NULL) + return NULL; + + while (*rootp != NULL) /* Knuth's T1: */ + { + int r; + + r = (*compar) (key, (*rootp)->key); + if (r == 0) /* T2: */ + return *rootp; /* we found it! */ + rootp = (r < 0) + ? &(*rootp)->left /* T3: follow left branch */ + : &(*rootp)->right; /* T4: follow right branch */ + } + + q = (node *) malloc (sizeof (node)); /* T5: key not found */ + if (q != NULL) /* make new node */ + { + *rootp = q; /* link new node to old */ + q->key = key; /* initialize new node */ + q->left = q->right = NULL; + } + + return q; +} + + +void * +tfind (key, vrootp, compar) + const void *key; + const void **vrootp; + __compar_fn_t compar; +{ + node **rootp = (node **) vrootp; + + if (rootp == NULL) + return NULL; + + while (*rootp != NULL) /* Knuth's T1: */ + { + int r; + + r = (*compar)(key, (*rootp)->key); + if (r == 0) /* T2: */ + return *rootp; /* we found it! */ + + rootp = (r < 0) + ? &(*rootp)->left /* T3: follow left branch */ + : &(*rootp)->right; /* T4: follow right branch */ + } + return NULL; +} + + +/* delete node with given key +char *key; key to be deleted +node **rootp; address of the root of tree +int (*compar)(); comparison function +*/ +void * +tdelete (key, vrootp, compar) + const void *key; + void **vrootp; + __compar_fn_t compar; +{ + node *p; + node *q; + node *r; + int cmp; + node **rootp = (node **) vrootp; + + if (rootp == NULL || (p = *rootp) == NULL) + return NULL; + + while ((cmp = (*compar) (key, (*rootp)->key)) != 0) + { + p = *rootp; + rootp = (cmp < 0) + ? &(*rootp)->left /* follow left branch */ + : &(*rootp)->right; /* follow right branch */ + if (*rootp == NULL) + return NULL; /* key not found */ + } + + r = (*rootp)->right; /* D1: */ + q = (*rootp)->left; + if (q == NULL) /* Left NULL? */ + q = r; + else if (r != NULL) /* Right link is NULL? */ + { + if (r->left == NULL) /* D2: Find successor */ + { + r->left = q; + q = r; + } + else + { /* D3: Find (struct node_t *)0 link */ + for (q = r->left; q->left != NULL; q = r->left) + r = q; + r->left = q->right; + q->left = (*rootp)->left; + q->right = (*rootp)->right; + } + } + free ((struct node_t *) *rootp); /* D4: Free node */ + *rootp = q; /* link parent to new node */ + return p; +} + + +/* Walk the nodes of a tree +node *root; Root of the tree to be walked +void (*action)(); Function to be called at each node +int level; +*/ +static void +trecurse (vroot, action, level) + const void *vroot; + __action_fn_t action; + int level; +{ + node *root = (node *) vroot; + + if (root->left == NULL && root->right == NULL) + (*action) (root, leaf, level); + else + { + (*action) (root, preorder, level); + if (root->left != NULL) + trecurse (root->left, action, level + 1); + (*action) (root, postorder, level); + if (root->right != NULL) + trecurse (root->right, action, level + 1); + (*action) (root, endorder, level); + } +} + + +/* void twalk(root, action) Walk the nodes of a tree +node *root; Root of the tree to be walked +void (*action)(); Function to be called at each node +PTR +*/ +void +twalk (vroot, action) + const void *vroot; + __action_fn_t action; +{ + const node *root = (node *) vroot; + + if (root != NULL && action != NULL) + trecurse (root, action, 0); +} |