Update.
[glibc.git] / misc / tsearch.c
blob7c3a0aaa78ac7fb0a5ea9680447f381c0cafcb2f
1 /* Copyright (C) 1995, 1996, 1997, 2000 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Bernd Schmidt <crux@Pool.Informatik.RWTH-Aachen.DE>, 1997.
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, write to the Free
17 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18 02111-1307 USA. */
20 /* Tree search for red/black trees.
21 The algorithm for adding nodes is taken from one of the many "Algorithms"
22 books by Robert Sedgewick, although the implementation differs.
23 The algorithm for deleting nodes can probably be found in a book named
24 "Introduction to Algorithms" by Cormen/Leiserson/Rivest. At least that's
25 the book that my professor took most algorithms from during the "Data
26 Structures" course...
28 Totally public domain. */
30 /* Red/black trees are binary trees in which the edges are colored either red
31 or black. They have the following properties:
32 1. The number of black edges on every path from the root to a leaf is
33 constant.
34 2. No two red edges are adjacent.
35 Therefore there is an upper bound on the length of every path, it's
36 O(log n) where n is the number of nodes in the tree. No path can be longer
37 than 1+2*P where P is the length of the shortest path in the tree.
38 Useful for the implementation:
39 3. If one of the children of a node is NULL, then the other one is red
40 (if it exists).
42 In the implementation, not the edges are colored, but the nodes. The color
43 interpreted as the color of the edge leading to this node. The color is
44 meaningless for the root node, but we color the root node black for
45 convenience. All added nodes are red initially.
47 Adding to a red/black tree is rather easy. The right place is searched
48 with a usual binary tree search. Additionally, whenever a node N is
49 reached that has two red successors, the successors are colored black and
50 the node itself colored red. This moves red edges up the tree where they
51 pose less of a problem once we get to really insert the new node. Changing
52 N's color to red may violate rule 2, however, so rotations may become
53 necessary to restore the invariants. Adding a new red leaf may violate
54 the same rule, so afterwards an additional check is run and the tree
55 possibly rotated.
57 Deleting is hairy. There are mainly two nodes involved: the node to be
58 deleted (n1), and another node that is to be unchained from the tree (n2).
59 If n1 has a successor (the node with a smallest key that is larger than
60 n1), then the successor becomes n2 and its contents are copied into n1,
61 otherwise n1 becomes n2.
62 Unchaining a node may violate rule 1: if n2 is black, one subtree is
63 missing one black edge afterwards. The algorithm must try to move this
64 error upwards towards the root, so that the subtree that does not have
65 enough black edges becomes the whole tree. Once that happens, the error
66 has disappeared. It may not be necessary to go all the way up, since it
67 is possible that rotations and recoloring can fix the error before that.
69 Although the deletion algorithm must walk upwards through the tree, we
70 do not store parent pointers in the nodes. Instead, delete allocates a
71 small array of parent pointers and fills it while descending the tree.
72 Since we know that the length of a path is O(log n), where n is the number
73 of nodes, this is likely to use less memory. */
75 /* Tree rotations look like this:
76 A C
77 / \ / \
78 B C A G
79 / \ / \ --> / \
80 D E F G B F
81 / \
82 D E
84 In this case, A has been rotated left. This preserves the ordering of the
85 binary tree. */
87 #include <stdlib.h>
88 #include <string.h>
89 #include <search.h>
91 typedef struct node_t
93 /* Callers expect this to be the first element in the structure - do not
94 move! */
95 const void *key;
96 struct node_t *left;
97 struct node_t *right;
98 unsigned int red:1;
99 } *node;
100 typedef const struct node_t *const_node;
102 #undef DEBUGGING
104 #ifdef DEBUGGING
106 /* Routines to check tree invariants. */
108 #include <assert.h>
110 #define CHECK_TREE(a) check_tree(a)
112 static void
113 check_tree_recurse (node p, int d_sofar, int d_total)
115 if (p == NULL)
117 assert (d_sofar == d_total);
118 return;
121 check_tree_recurse (p->left, d_sofar + (p->left && !p->left->red), d_total);
122 check_tree_recurse (p->right, d_sofar + (p->right && !p->right->red), d_total);
123 if (p->left)
124 assert (!(p->left->red && p->red));
125 if (p->right)
126 assert (!(p->right->red && p->red));
129 static void
130 check_tree (node root)
132 int cnt = 0;
133 node p;
134 if (root == NULL)
135 return;
136 root->red = 0;
137 for(p = root->left; p; p = p->left)
138 cnt += !p->red;
139 check_tree_recurse (root, 0, cnt);
143 #else
145 #define CHECK_TREE(a)
147 #endif
149 /* Possibly "split" a node with two red successors, and/or fix up two red
150 edges in a row. ROOTP is a pointer to the lowest node we visited, PARENTP
151 and GPARENTP pointers to its parent/grandparent. P_R and GP_R contain the
152 comparison values that determined which way was taken in the tree to reach
153 ROOTP. MODE is 1 if we need not do the split, but must check for two red
154 edges between GPARENTP and ROOTP. */
155 static void
156 maybe_split_for_insert (node *rootp, node *parentp, node *gparentp,
157 int p_r, int gp_r, int mode)
159 node root = *rootp;
160 node *rp, *lp;
161 rp = &(*rootp)->right;
162 lp = &(*rootp)->left;
164 /* See if we have to split this node (both successors red). */
165 if (mode == 1
166 || ((*rp) != NULL && (*lp) != NULL && (*rp)->red && (*lp)->red))
168 /* This node becomes red, its successors black. */
169 root->red = 1;
170 if (*rp)
171 (*rp)->red = 0;
172 if (*lp)
173 (*lp)->red = 0;
175 /* If the parent of this node is also red, we have to do
176 rotations. */
177 if (parentp != NULL && (*parentp)->red)
179 node gp = *gparentp;
180 node p = *parentp;
181 /* There are two main cases:
182 1. The edge types (left or right) of the two red edges differ.
183 2. Both red edges are of the same type.
184 There exist two symmetries of each case, so there is a total of
185 4 cases. */
186 if ((p_r > 0) != (gp_r > 0))
188 /* Put the child at the top of the tree, with its parent
189 and grandparent as successors. */
190 p->red = 1;
191 gp->red = 1;
192 root->red = 0;
193 if (p_r < 0)
195 /* Child is left of parent. */
196 p->left = *rp;
197 *rp = p;
198 gp->right = *lp;
199 *lp = gp;
201 else
203 /* Child is right of parent. */
204 p->right = *lp;
205 *lp = p;
206 gp->left = *rp;
207 *rp = gp;
209 *gparentp = root;
211 else
213 *gparentp = *parentp;
214 /* Parent becomes the top of the tree, grandparent and
215 child are its successors. */
216 p->red = 0;
217 gp->red = 1;
218 if (p_r < 0)
220 /* Left edges. */
221 gp->left = p->right;
222 p->right = gp;
224 else
226 /* Right edges. */
227 gp->right = p->left;
228 p->left = gp;
235 /* Find or insert datum into search tree.
236 KEY is the key to be located, ROOTP is the address of tree root,
237 COMPAR the ordering function. */
238 void *
239 __tsearch (const void *key, void **vrootp, __compar_fn_t compar)
241 node q;
242 node *parentp = NULL, *gparentp = NULL;
243 node *rootp = (node *) vrootp;
244 node *nextp;
245 int r = 0, p_r = 0, gp_r = 0; /* No they might not, Mr Compiler. */
247 if (rootp == NULL)
248 return NULL;
250 /* This saves some additional tests below. */
251 if (*rootp != NULL)
252 (*rootp)->red = 0;
254 CHECK_TREE (*rootp);
256 nextp = rootp;
257 while (*nextp != NULL)
259 node root = *rootp;
260 r = (*compar) (key, root->key);
261 if (r == 0)
262 return root;
264 maybe_split_for_insert (rootp, parentp, gparentp, p_r, gp_r, 0);
265 /* If that did any rotations, parentp and gparentp are now garbage.
266 That doesn't matter, because the values they contain are never
267 used again in that case. */
269 nextp = r < 0 ? &root->left : &root->right;
270 if (*nextp == NULL)
271 break;
273 gparentp = parentp;
274 parentp = rootp;
275 rootp = nextp;
277 gp_r = p_r;
278 p_r = r;
281 q = (struct node_t *) malloc (sizeof (struct node_t));
282 if (q != NULL)
284 *nextp = q; /* link new node to old */
285 q->key = key; /* initialize new node */
286 q->red = 1;
287 q->left = q->right = NULL;
289 if (nextp != rootp)
290 /* There may be two red edges in a row now, which we must avoid by
291 rotating the tree. */
292 maybe_split_for_insert (nextp, rootp, parentp, r, p_r, 1);
294 return q;
296 weak_alias (__tsearch, tsearch)
299 /* Find datum in search tree.
300 KEY is the key to be located, ROOTP is the address of tree root,
301 COMPAR the ordering function. */
302 void *
303 __tfind (key, vrootp, compar)
304 const void *key;
305 void *const *vrootp;
306 __compar_fn_t compar;
308 node *rootp = (node *) vrootp;
310 if (rootp == NULL)
311 return NULL;
313 CHECK_TREE (*rootp);
315 while (*rootp != NULL)
317 node root = *rootp;
318 int r;
320 r = (*compar) (key, root->key);
321 if (r == 0)
322 return root;
324 rootp = r < 0 ? &root->left : &root->right;
326 return NULL;
328 weak_alias (__tfind, tfind)
331 /* Delete node with given key.
332 KEY is the key to be deleted, ROOTP is the address of the root of tree,
333 COMPAR the comparison function. */
334 void *
335 __tdelete (const void *key, void **vrootp, __compar_fn_t compar)
337 node p, q, r, retval;
338 int cmp;
339 node *rootp = (node *) vrootp;
340 node root, unchained;
341 /* Stack of nodes so we remember the parents without recursion. It's
342 _very_ unlikely that there are paths longer than 40 nodes. The tree
343 would need to have around 250.000 nodes. */
344 int stacksize = 40;
345 int sp = 0;
346 node **nodestack = alloca (sizeof (node *) * stacksize);
348 if (rootp == NULL)
349 return NULL;
350 p = *rootp;
351 if (p == NULL)
352 return NULL;
354 CHECK_TREE (p);
356 while ((cmp = (*compar) (key, (*rootp)->key)) != 0)
358 if (sp == stacksize)
360 node **newstack;
361 stacksize += 20;
362 newstack = alloca (sizeof (node *) * stacksize);
363 nodestack = memcpy (newstack, nodestack, sp * sizeof (node *));
366 nodestack[sp++] = rootp;
367 p = *rootp;
368 rootp = ((cmp < 0)
369 ? &(*rootp)->left
370 : &(*rootp)->right);
371 if (*rootp == NULL)
372 return NULL;
375 /* This is bogus if the node to be deleted is the root... this routine
376 really should return an integer with 0 for success, -1 for failure
377 and errno = ESRCH or something. */
378 retval = p;
380 /* We don't unchain the node we want to delete. Instead, we overwrite
381 it with its successor and unchain the successor. If there is no
382 successor, we really unchain the node to be deleted. */
384 root = *rootp;
386 r = root->right;
387 q = root->left;
389 if (q == NULL || r == NULL)
390 unchained = root;
391 else
393 node *parent = rootp, *up = &root->right;
394 for (;;)
396 if (sp == stacksize)
398 node **newstack;
399 stacksize += 20;
400 newstack = alloca (sizeof (node *) * stacksize);
401 nodestack = memcpy (newstack, nodestack, sp * sizeof (node *));
403 nodestack[sp++] = parent;
404 parent = up;
405 if ((*up)->left == NULL)
406 break;
407 up = &(*up)->left;
409 unchained = *up;
412 /* We know that either the left or right successor of UNCHAINED is NULL.
413 R becomes the other one, it is chained into the parent of UNCHAINED. */
414 r = unchained->left;
415 if (r == NULL)
416 r = unchained->right;
417 if (sp == 0)
418 *rootp = r;
419 else
421 q = *nodestack[sp-1];
422 if (unchained == q->right)
423 q->right = r;
424 else
425 q->left = r;
428 if (unchained != root)
429 root->key = unchained->key;
430 if (!unchained->red)
432 /* Now we lost a black edge, which means that the number of black
433 edges on every path is no longer constant. We must balance the
434 tree. */
435 /* NODESTACK now contains all parents of R. R is likely to be NULL
436 in the first iteration. */
437 /* NULL nodes are considered black throughout - this is necessary for
438 correctness. */
439 while (sp > 0 && (r == NULL || !r->red))
441 node *pp = nodestack[sp - 1];
442 p = *pp;
443 /* Two symmetric cases. */
444 if (r == p->left)
446 /* Q is R's brother, P is R's parent. The subtree with root
447 R has one black edge less than the subtree with root Q. */
448 q = p->right;
449 if (q != NULL && q->red)
451 /* If Q is red, we know that P is black. We rotate P left
452 so that Q becomes the top node in the tree, with P below
453 it. P is colored red, Q is colored black.
454 This action does not change the black edge count for any
455 leaf in the tree, but we will be able to recognize one
456 of the following situations, which all require that Q
457 is black. */
458 q->red = 0;
459 p->red = 1;
460 /* Left rotate p. */
461 p->right = q->left;
462 q->left = p;
463 *pp = q;
464 /* Make sure pp is right if the case below tries to use
465 it. */
466 nodestack[sp++] = pp = &q->left;
467 q = p->right;
469 /* We know that Q can't be NULL here. We also know that Q is
470 black. */
471 if ((q->left == NULL || !q->left->red)
472 && (q->right == NULL || !q->right->red))
474 /* Q has two black successors. We can simply color Q red.
475 The whole subtree with root P is now missing one black
476 edge. Note that this action can temporarily make the
477 tree invalid (if P is red). But we will exit the loop
478 in that case and set P black, which both makes the tree
479 valid and also makes the black edge count come out
480 right. If P is black, we are at least one step closer
481 to the root and we'll try again the next iteration. */
482 q->red = 1;
483 r = p;
485 else
487 /* Q is black, one of Q's successors is red. We can
488 repair the tree with one operation and will exit the
489 loop afterwards. */
490 if (q->right == NULL || !q->right->red)
492 /* The left one is red. We perform the same action as
493 in maybe_split_for_insert where two red edges are
494 adjacent but point in different directions:
495 Q's left successor (let's call it Q2) becomes the
496 top of the subtree we are looking at, its parent (Q)
497 and grandparent (P) become its successors. The former
498 successors of Q2 are placed below P and Q.
499 P becomes black, and Q2 gets the color that P had.
500 This changes the black edge count only for node R and
501 its successors. */
502 node q2 = q->left;
503 q2->red = p->red;
504 p->right = q2->left;
505 q->left = q2->right;
506 q2->right = q;
507 q2->left = p;
508 *pp = q2;
509 p->red = 0;
511 else
513 /* It's the right one. Rotate P left. P becomes black,
514 and Q gets the color that P had. Q's right successor
515 also becomes black. This changes the black edge
516 count only for node R and its successors. */
517 q->red = p->red;
518 p->red = 0;
520 q->right->red = 0;
522 /* left rotate p */
523 p->right = q->left;
524 q->left = p;
525 *pp = q;
528 /* We're done. */
529 sp = 1;
530 r = NULL;
533 else
535 /* Comments: see above. */
536 q = p->left;
537 if (q != NULL && q->red)
539 q->red = 0;
540 p->red = 1;
541 p->left = q->right;
542 q->right = p;
543 *pp = q;
544 nodestack[sp++] = pp = &q->right;
545 q = p->left;
547 if ((q->right == NULL || !q->right->red)
548 && (q->left == NULL || !q->left->red))
550 q->red = 1;
551 r = p;
553 else
555 if (q->left == NULL || !q->left->red)
557 node q2 = q->right;
558 q2->red = p->red;
559 p->left = q2->right;
560 q->right = q2->left;
561 q2->left = q;
562 q2->right = p;
563 *pp = q2;
564 p->red = 0;
566 else
568 q->red = p->red;
569 p->red = 0;
570 q->left->red = 0;
571 p->left = q->right;
572 q->right = p;
573 *pp = q;
575 sp = 1;
576 r = NULL;
579 --sp;
581 if (r != NULL)
582 r->red = 0;
585 free (unchained);
586 return retval;
588 weak_alias (__tdelete, tdelete)
591 /* Walk the nodes of a tree.
592 ROOT is the root of the tree to be walked, ACTION the function to be
593 called at each node. LEVEL is the level of ROOT in the whole tree. */
594 static void
595 internal_function
596 trecurse (const void *vroot, __action_fn_t action, int level)
598 const_node root = (const_node) vroot;
600 if (root->left == NULL && root->right == NULL)
601 (*action) (root, leaf, level);
602 else
604 (*action) (root, preorder, level);
605 if (root->left != NULL)
606 trecurse (root->left, action, level + 1);
607 (*action) (root, postorder, level);
608 if (root->right != NULL)
609 trecurse (root->right, action, level + 1);
610 (*action) (root, endorder, level);
615 /* Walk the nodes of a tree.
616 ROOT is the root of the tree to be walked, ACTION the function to be
617 called at each node. */
618 void
619 __twalk (const void *vroot, __action_fn_t action)
621 const_node root = (const_node) vroot;
623 CHECK_TREE (root);
625 if (root != NULL && action != NULL)
626 trecurse (root, action, 0);
628 weak_alias (__twalk, twalk)
632 /* The standardized functions miss an important functionality: the
633 tree cannot be removed easily. We provide a function to do this. */
634 static void
635 internal_function
636 tdestroy_recurse (node root, __free_fn_t freefct)
638 if (root->left != NULL)
639 tdestroy_recurse (root->left, freefct);
640 if (root->right != NULL)
641 tdestroy_recurse (root->right, freefct);
642 (*freefct) ((void *) root->key);
643 /* Free the node itself. */
644 free (root);
647 void
648 __tdestroy (void *vroot, __free_fn_t freefct)
650 node root = (node) vroot;
652 CHECK_TREE (root);
654 if (root != NULL)
655 tdestroy_recurse (root, freefct);
657 weak_alias (__tdestroy, tdestroy)