home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / info-service / www / src / WWW / Library / Implementation / HTBTree.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-12  |  24.8 KB  |  655 lines
  1. /*                  Binary Tree for sorting things
  2. **                  ==============================
  3. **                      Author: Arthur Secret
  4. */
  5.  
  6.  
  7. #include "HTUtils.h"
  8. #include "HTBTree.h"
  9. #include <stdlib.h>
  10. #include <string.h>
  11.  
  12. #define MAXIMUM(a,b) ((a)>(b)?(a):(b))
  13.  
  14.  
  15.  
  16.  
  17.  
  18. PUBLIC HTBTree * HTBTree_new ARGS1(HTComparer, comp)
  19.     /*********************************************************
  20.     ** This function returns an HTBTree with memory allocated 
  21.     ** for it when given a mean to compare things
  22.     */
  23. {
  24.     HTBTree * tree = (HTBTree *)malloc(sizeof(HTBTree));
  25.     if (tree==NULL) outofmem(__FILE__, "HTBTree_new");
  26.  
  27.     tree->compare = comp;
  28.     tree->top = NULL;
  29.  
  30.     return tree;
  31. }
  32.  
  33.  
  34.  
  35.  
  36. PRIVATE void HTBTElement_free ARGS1(HTBTElement*, element)
  37.     /**********************************************************
  38.     ** This void will free the memory allocated for one element
  39.     */
  40. {
  41.     if (element) {
  42.         if (element->left != NULL)    HTBTElement_free(element->left);
  43.     if (element->right != NULL)    HTBTElement_free(element->right);
  44.     free(element);
  45.     }
  46. }
  47.  
  48. PUBLIC void HTBTree_free ARGS1(HTBTree*, tree)
  49.     /**************************************************************
  50.     ** This void will free the memory allocated for the whole tree
  51.     */
  52. {
  53.     HTBTElement_free(tree->top);
  54.     free(tree);
  55. }
  56.  
  57.  
  58.  
  59.  
  60. PRIVATE void HTBTElementAndObject_free ARGS1(HTBTElement*, element)
  61.     /**********************************************************
  62.     ** This void will free the memory allocated for one element
  63.     */
  64. {
  65.     if (element) {     /* Just in case nothing was in the tree anyway */
  66.         if (element->left != NULL)    HTBTElementAndObject_free(element->left);
  67.     if (element->right != NULL)    
  68.         HTBTElementAndObject_free(element->right);
  69.     free(element->object);
  70.     free(element);
  71.     }
  72. }
  73.  
  74. PUBLIC void HTBTreeAndObject_free ARGS1(HTBTree*, tree)
  75.     /**************************************************************
  76.     ** This void will free the memory allocated for the whole tree
  77.     */
  78. {
  79.     HTBTElementAndObject_free(tree->top);
  80.     free(tree);
  81. }
  82.  
  83.  
  84.  
  85.  
  86. PUBLIC void HTBTree_add ARGS2(
  87.             HTBTree*,  tree,
  88.             void*,     object)
  89.     /**********************************************************************
  90.     ** This void is the core of HTBTree.c . It will
  91.     **       1/ add a new element to the tree at the right place
  92.     **          so that the tree remains sorted
  93.     **       2/ balance the tree to be as fast as possible when reading it
  94.     */
  95. {
  96.     HTBTElement * father_of_element;
  97.     HTBTElement * added_element;
  98.     HTBTElement * forefather_of_element;
  99.     HTBTElement * father_of_forefather;
  100.     BOOL father_found,top_found,first_correction;
  101.     int depth,depth2;
  102.         /* father_of_element is a pointer to the structure that is the father of the
  103.         ** new object "object".
  104.         ** added_element is a pointer to the structure that contains or will contain 
  105.         ** the new object "object".
  106.         ** father_of_forefather and forefather_of_element are pointers that are used
  107.         ** to modify the depths of upper elements, when needed.
  108.         **
  109.         ** father_found indicates by a value NO when the future father of "object" 
  110.         ** is found.
  111.         ** top_found indicates by a value NO when, in case of a difference of depths
  112.         **  < 2, the top of the tree is encountered and forbids any further try to
  113.         ** balance the tree.
  114.         ** first_correction is a boolean used to avoid infinite loops in cases
  115.         ** such as:
  116.         **
  117.         **             3                        3
  118.         **          4                              4
  119.         **           5                            5
  120.         **
  121.         ** 3 is used here to show that it need not be the top of the tree.
  122.         */
  123.  
  124.     /*
  125.     ** 1/ Adding of the element to the binary tree
  126.     */
  127.  
  128.     if (tree->top == NULL)
  129.     {
  130.         tree->top = (HTBTElement *)malloc(sizeof(HTBTElement));
  131.         if (tree->top == NULL) outofmem(__FILE__, "HTBTree_add");
  132.         tree->top->up = NULL;
  133.         tree->top->object = object;
  134.         tree->top->left = NULL;
  135.         tree->top->left_depth = 0;
  136.         tree->top->right = NULL;
  137.         tree->top->right_depth = 0;
  138.     }
  139.     else
  140.     {   
  141.         father_found = YES;
  142.         father_of_element = tree->top;
  143.         added_element = NULL;
  144.         father_of_forefather = NULL;
  145.         forefather_of_element = NULL;      
  146.         while (father_found)
  147.         {
  148.             if (tree->compare(object,father_of_element->object)<0)
  149.         {
  150.                 if (father_of_element->left != NULL)
  151.                     father_of_element = father_of_element->left;
  152.                 else 
  153.             {
  154.                     father_found = NO;
  155.                     father_of_element->left = 
  156.                         (HTBTElement *)malloc(sizeof(HTBTElement));
  157.                     if (father_of_element->left==NULL) 
  158.                         outofmem(__FILE__, "HTBTree_add");
  159.                     added_element = father_of_element->left;
  160.                     added_element->up = father_of_element;
  161.                     added_element->object = object;
  162.                     added_element->left = NULL;
  163.                     added_element->left_depth = 0;
  164.                     added_element->right = NULL;
  165.                     added_element->right_depth = 0;
  166.                 }
  167.            }
  168.             if (tree->compare(object,father_of_element->object)>=0)
  169.             {
  170.                 if (father_of_element->right != NULL) 
  171.                     father_of_element = father_of_element->right;
  172.                 else 
  173.                 {  
  174.                     father_found = NO;
  175.                     father_of_element->right = 
  176.                         (HTBTElement *)malloc(sizeof(HTBTElement));
  177.                     if (father_of_element->right==NULL) 
  178.                         outofmem(__FILE__, "HTBTree_add");
  179.                     added_element = father_of_element->right;
  180.                     added_element->up = father_of_element;
  181.                     added_element->object = object;
  182.                     added_element->left = NULL;
  183.                     added_element->left_depth = 0;
  184.                     added_element->right = NULL;
  185.                     added_element->right_depth = 0;       
  186.                 }
  187.             }
  188.     }
  189.             /*
  190.             ** Changing of all depths that need to be changed
  191.             */
  192.         father_of_forefather = father_of_element;
  193.         forefather_of_element = added_element;
  194.         do
  195.         {
  196.             if (father_of_forefather->left == forefather_of_element)
  197.             {
  198.                 depth = father_of_forefather->left_depth;
  199.                 father_of_forefather->left_depth = 1 
  200.                             + MAXIMUM(forefather_of_element->right_depth,
  201.                                   forefather_of_element->left_depth);
  202.                 depth2 = father_of_forefather->left_depth;
  203.             }
  204.             else
  205.         {
  206.                 depth = father_of_forefather->right_depth;
  207.                 father_of_forefather->right_depth = 1
  208.                             + MAXIMUM(forefather_of_element->right_depth,
  209.                                   forefather_of_element->left_depth);
  210.                 depth2 = father_of_forefather->right_depth;
  211.             }
  212.             forefather_of_element = father_of_forefather;
  213.             father_of_forefather = father_of_forefather->up;
  214.         } while ((depth != depth2) && (father_of_forefather != NULL));
  215.         
  216.  
  217.             /*
  218.             ** 2/ Balancing the binary tree, if necessary
  219.             */
  220.         top_found = YES;
  221.         first_correction = YES;
  222.         while ((top_found) && (first_correction))
  223.         {
  224.             if ((abs(father_of_element->left_depth
  225.                       - father_of_element->right_depth)) < 2)
  226.         {
  227.                 if (father_of_element->up != NULL) 
  228.                     father_of_element = father_of_element->up;
  229.                 else top_found = NO;
  230.         }
  231.             else
  232.          {                /* We start the process of balancing */
  233.  
  234.                 first_correction = NO;
  235.                     /* 
  236.                     ** first_correction is a boolean used to avoid infinite 
  237.                     ** loops in cases such as:
  238.                     **
  239.                     **             3                        3
  240.                     **          4                              4
  241.                     **           5                            5
  242.                     **
  243.                     ** 3 is used to show that it need not be the top of the tree
  244.                     */
  245.  
  246.  
  247.                 if (father_of_element->left_depth > father_of_element->right_depth)
  248.             {
  249.                     added_element = father_of_element->left;
  250.                     father_of_element->left_depth = added_element->right_depth;
  251.                     added_element->right_depth = 1
  252.                                     + MAXIMUM(father_of_element->right_depth,
  253.                                           father_of_element->left_depth);
  254.                     if (father_of_element->up != NULL)
  255.             {
  256.                         father_of_forefather = father_of_element->up;
  257.                         forefather_of_element = added_element;
  258.                         do 
  259.                         {
  260.                             if (father_of_forefather->left
  261.                                  == forefather_of_element->up)
  262.                             {
  263.                                 depth = father_of_forefather->left_depth;
  264.                                 father_of_forefather->left_depth = 1
  265.                                     + MAXIMUM(forefather_of_element->left_depth,
  266.                                           forefather_of_element->right_depth);
  267.                                 depth2 = father_of_forefather->left_depth;
  268.                 }
  269.                             else
  270.                 {
  271.                                 depth = father_of_forefather->right_depth;
  272.                                 father_of_forefather->right_depth = 1
  273.                                     + MAXIMUM(forefather_of_element->left_depth,
  274.                                           forefather_of_element->right_depth);
  275.                                 depth2 = father_of_forefather->right_depth;
  276.                 }
  277.                             forefather_of_element = father_of_forefather;
  278.                             father_of_forefather = father_of_forefather->up;
  279.             } while ((depth != depth2) && 
  280.                  (father_of_forefather != NULL));
  281.                         father_of_forefather = father_of_element->up;
  282.                         if (father_of_forefather->left == father_of_element)
  283.                     {
  284.                             /*
  285.                             **                   3                       3
  286.                             **               4                       5
  287.                             ** When tree   5   6        becomes    7    4
  288.                             **            7 8                          8 6
  289.                             **
  290.                             ** 3 is used to show that it may not be the top of the
  291.                             ** tree.
  292.                             */ 
  293.                             father_of_forefather->left = added_element;
  294.                             father_of_element->left = added_element->right;
  295.                             added_element->right = father_of_element;
  296.                         }
  297.                         if (father_of_forefather->right == father_of_element)
  298.                 {
  299.                             /*
  300.                             **          3                       3
  301.                             **               4                       5
  302.                             ** When tree   5   6        becomes    7    4
  303.                             **            7 8                          8 6
  304.                             **
  305.                             ** 3 is used to show that it may not be the top of the
  306.                             ** tree
  307.                             */
  308.                             father_of_forefather->right = added_element;
  309.                             father_of_element->left = added_element->right;
  310.                             added_element->right = father_of_element;
  311.                         }
  312.                         added_element->up = father_of_forefather;
  313.             }
  314.                     else
  315.             {
  316.                         /*
  317.                         **
  318.                         **               1                       2
  319.                         ** When tree   2   3        becomes    4    1
  320.                         **            4 5                          5 3
  321.                         **
  322.                         ** 1 is used to show that it is the top of the tree    
  323.                         */
  324.                         added_element->up = NULL;
  325.                         father_of_element->left = added_element->right;
  326.                         added_element->right = father_of_element;
  327.             }
  328.                     father_of_element->up = added_element;
  329.                     if (father_of_element->left != NULL)
  330.                         father_of_element->left->up = father_of_element;
  331.             }
  332.                 else
  333.             {
  334.                     added_element = father_of_element->right;
  335.                     father_of_element->right_depth = added_element->left_depth;
  336.                     added_element->left_depth = 1 + 
  337.                             MAXIMUM(father_of_element->right_depth,
  338.                                 father_of_element->left_depth);
  339.                     if (father_of_element->up != NULL)
  340.             {
  341.                         father_of_forefather = father_of_element->up;
  342.                         forefather_of_element = added_element;
  343.                         do 
  344.                         {
  345.                             if (father_of_forefather->left == father_of_element)
  346.                             {
  347.                                 depth = father_of_forefather->left_depth;
  348.                                 father_of_forefather->left_depth = 1
  349.                                                  + MAXIMUM(added_element->left_depth,
  350.                                                          added_element->right_depth);
  351.                                 depth2 = father_of_forefather->left_depth;
  352.                 }
  353.                             else
  354.                 {
  355.                                 depth = father_of_forefather->right_depth;
  356.                                 father_of_forefather->right_depth = 1
  357.                                                  + MAXIMUM(added_element->left_depth,
  358.                                                          added_element->right_depth);
  359.                                 depth2 = father_of_forefather->right_depth;
  360.                 }
  361.                             father_of_forefather = father_of_forefather->up;
  362.                             forefather_of_element = father_of_forefather;
  363.             } while ((depth != depth2) && 
  364.                  (father_of_forefather != NULL));
  365.                         father_of_forefather = father_of_element->up;
  366.                         if (father_of_forefather->left == father_of_element)
  367.                 {
  368.                             /*
  369.                             **                    3                       3
  370.                             **               4                       6
  371.                             ** When tree   5   6        becomes    4    8
  372.                             **                7 8                 5 7
  373.                             **
  374.                             ** 3 is used to show that it may not be the top of the
  375.                             ** tree.
  376.                             */
  377.                             father_of_forefather->left = added_element;
  378.                             father_of_element->right = added_element->left;
  379.                             added_element->left = father_of_element;
  380.                         }
  381.                         if (father_of_forefather->right == father_of_element)
  382.                 {
  383.                             /*
  384.                             **           3                      3
  385.                             **               4                       6
  386.                             ** When tree   5   6        becomes    4    8
  387.                             **                7 8                 5 7
  388.                             **
  389.                             ** 3 is used to show that it may not be the top of the
  390.                             ** tree
  391.                             */
  392.                             father_of_forefather->right = added_element;
  393.                             father_of_element->right = added_element->left;
  394.                             added_element->left = father_of_element;
  395.                         }
  396.                         added_element->up = father_of_forefather;
  397.             }
  398.                     else
  399.                     {
  400.                         /*
  401.                         **
  402.                         **               1                       3
  403.                         ** When tree   2   3        becomes    1    5
  404.                         **                4 5                 2 4
  405.                         **
  406.                         ** 1 is used to show that it is the top of the tree.
  407.                         */
  408.                         added_element->up = NULL;
  409.                         father_of_element->right = added_element->left;
  410.                         added_element->left = father_of_element;
  411.             }
  412.                     father_of_element->up = added_element;
  413.                     if (father_of_element->right != NULL)
  414.                 father_of_element->right->up = father_of_element;
  415.         }
  416.         }
  417.         }
  418.         while (father_of_element->up != NULL)
  419.     {
  420.             father_of_element = father_of_element->up;
  421.         }
  422.         tree->top = father_of_element;
  423.     }
  424. }
  425.  
  426.  
  427.  
  428. PUBLIC HTBTElement * HTBTree_next ARGS2(
  429.                                HTBTree*,       tree,
  430.                                HTBTElement*,   ele)
  431.     /**************************************************************************
  432.     ** this function returns a pointer to the leftmost element if ele is NULL,
  433.     ** and to the next object to the right otherways.
  434.     ** If no elements left, returns a pointer to NULL.
  435.     */
  436. {
  437.     HTBTElement * father_of_element;
  438.     HTBTElement * father_of_forefather;
  439.  
  440.     if (ele == NULL)
  441.     {
  442.         father_of_element = tree->top;
  443.         if (father_of_element != NULL)
  444.             while (father_of_element->left != NULL)
  445.                 father_of_element = father_of_element->left;
  446.     }
  447.     else
  448.     {
  449.         father_of_element = ele;
  450.         if (father_of_element->right != NULL)
  451.     {
  452.             father_of_element = father_of_element->right;
  453.             while (father_of_element->left != NULL)
  454.                 father_of_element = father_of_element->left;
  455.     }
  456.         else
  457.     {
  458.             father_of_forefather = father_of_element->up;
  459.             while (father_of_forefather && 
  460.                (father_of_forefather->right == father_of_element))
  461.                   {
  462.                     father_of_element = father_of_forefather;
  463.             father_of_forefather = father_of_element->up;
  464.         }
  465.             father_of_element = father_of_forefather;
  466.     }
  467.     }
  468. #ifdef BTREE_TRACE
  469.     /* The option -DBTREE_TRACE will give much more information
  470.     ** about the way the process is running, for debugging matters
  471.     */
  472.     if (father_of_element != NULL)
  473.     {
  474.         printf("\nObject = %s\t",(char *)father_of_element->object);
  475.         if (father_of_element->up != NULL)
  476.             printf("Objet du pere = %s\n",
  477.            (char *)father_of_element->up->object);
  478.         else printf("Pas de Pere\n");
  479.         if (father_of_element->left != NULL)
  480.             printf("Objet du fils gauche = %s\t",
  481.            (char *)father_of_element->left->object); 
  482.         else printf("Pas de fils gauche\t");
  483.         if (father_of_element->right != NULL)
  484.             printf("Objet du fils droit = %s\n",
  485.            (char *)father_of_element->right->object);
  486.         else printf("Pas de fils droit\n");
  487.         printf("Profondeur gauche = %i\t",father_of_element->left_depth);
  488.         printf("Profondeur droite = %i\n",father_of_element->right_depth);
  489.         printf("      **************\n");
  490.     }
  491. #endif
  492.     return father_of_element;
  493. }
  494.  
  495.  
  496. #ifdef TEST
  497. main ()
  498.     /******************************************************
  499.     ** This is just a test to show how to handle HTBTree.c
  500.     */
  501. {
  502.     HTBTree * tree;
  503.     HTBTElement * next_element;
  504.     
  505.     tree = HTBTree_new((HTComparer)strcasecmp);
  506.     HTBTree_add(tree,"hypertext");
  507.     HTBTree_add(tree,"Addressing");
  508.     HTBTree_add(tree,"X11");
  509.     HTBTree_add(tree,"Tools");
  510.     HTBTree_add(tree,"Proposal.wn");
  511.     HTBTree_add(tree,"Protocols");
  512.     HTBTree_add(tree,"NeXT");
  513.     HTBTree_add(tree,"Daemon");
  514.     HTBTree_add(tree,"Test");
  515.     HTBTree_add(tree,"Administration");
  516.     HTBTree_add(tree,"LineMode");
  517.     HTBTree_add(tree,"DesignIssues");
  518.     HTBTree_add(tree,"MarkUp");
  519.     HTBTree_add(tree,"Macintosh");
  520.     HTBTree_add(tree,"Proposal.rtf.wn");
  521.     HTBTree_add(tree,"FIND");
  522.     HTBTree_add(tree,"Paper");
  523.     HTBTree_add(tree,"Tcl");
  524.     HTBTree_add(tree,"Talks");
  525.     HTBTree_add(tree,"Architecture");
  526.     HTBTree_add(tree,"VMSHelp");
  527.     HTBTree_add(tree,"Provider");
  528.     HTBTree_add(tree,"Archive");
  529.     HTBTree_add(tree,"SLAC");
  530.     HTBTree_add(tree,"Project");
  531.     HTBTree_add(tree,"News");
  532.     HTBTree_add(tree,"Viola");
  533.     HTBTree_add(tree,"Users");
  534.     HTBTree_add(tree,"FAQ");
  535.     HTBTree_add(tree,"WorkingNotes");
  536.     HTBTree_add(tree,"Windows");
  537.     HTBTree_add(tree,"FineWWW");
  538.     HTBTree_add(tree,"Frame");
  539.     HTBTree_add(tree,"XMosaic");
  540.     HTBTree_add(tree,"People");
  541.     HTBTree_add(tree,"All");
  542.     HTBTree_add(tree,"Curses");
  543.     HTBTree_add(tree,"Erwise");
  544.     HTBTree_add(tree,"Carl");
  545.     HTBTree_add(tree,"MidasWWW");
  546.     HTBTree_add(tree,"XPM");
  547.     HTBTree_add(tree,"MailRobot");
  548.     HTBTree_add(tree,"Illustrations");
  549.     HTBTree_add(tree,"VMClient");
  550.     HTBTree_add(tree,"XPA");
  551.     HTBTree_add(tree,"Clients.html");
  552.     HTBTree_add(tree,"Library");
  553.     HTBTree_add(tree,"CERNLIB_Distribution");
  554.     HTBTree_add(tree,"libHTML");
  555.     HTBTree_add(tree,"WindowsPC");
  556.     HTBTree_add(tree,"tkWWW");
  557.     HTBTree_add(tree,"tk2.3");
  558.     HTBTree_add(tree,"CVS-RCS");
  559.     HTBTree_add(tree,"DecnetSockets");
  560.     HTBTree_add(tree,"SGMLStream");
  561.     HTBTree_add(tree,"NextStep");
  562.     HTBTree_add(tree,"CVSRepository_old");
  563.     HTBTree_add(tree,"ArthurSecret");
  564.     HTBTree_add(tree,"CVSROOT");
  565.     HTBTree_add(tree,"HytelnetGate");
  566.     HTBTree_add(tree,"cern.www.new.src");
  567.     HTBTree_add(tree,"Conditions");
  568.     HTBTree_add(tree,"HTMLGate");
  569.     HTBTree_add(tree,"Makefile");
  570.     HTBTree_add(tree,"Newsgroups.html");
  571.     HTBTree_add(tree,"People.html");
  572.     HTBTree_add(tree,"Bugs.html");
  573.     HTBTree_add(tree,"Summary.html");
  574.     HTBTree_add(tree,"zDesignIssues.wn");
  575.     HTBTree_add(tree,"HT.draw");
  576.     HTBTree_add(tree,"HTandCERN.wn");
  577.     HTBTree_add(tree,"Ideas.wn");
  578.     HTBTree_add(tree,"MarkUp.wn");
  579.     HTBTree_add(tree,"Proposal.html");
  580.     HTBTree_add(tree,"SearchPanel.draw");
  581.     HTBTree_add(tree,"Comments.wn");
  582.     HTBTree_add(tree,"Xanadu.html");
  583.     HTBTree_add(tree,"Storinglinks.html");
  584.     HTBTree_add(tree,"TheW3Book.html");
  585.     HTBTree_add(tree,"Talk_Feb-91.html");
  586.     HTBTree_add(tree,"JFosterEntry.txt");
  587.     HTBTree_add(tree,"Summary.txt");
  588.     HTBTree_add(tree,"Bibliography.html");
  589.     HTBTree_add(tree,"HTandCern.txt");
  590.     HTBTree_add(tree,"Talk.draw");
  591.     HTBTree_add(tree,"zDesignNotes.html");
  592.     HTBTree_add(tree,"Link.html");
  593.     HTBTree_add(tree,"Status.html");
  594.     HTBTree_add(tree,"http.txt");
  595.     HTBTree_add(tree,"People.html~");
  596.     HTBTree_add(tree,"TAGS");
  597.     HTBTree_add(tree,"summary.txt");
  598.     HTBTree_add(tree,"Technical.html");
  599.     HTBTree_add(tree,"Terms.html");
  600.     HTBTree_add(tree,"JANETAccess.html");
  601.     HTBTree_add(tree,"People.txt");
  602.     HTBTree_add(tree,"README.txt");
  603.     HTBTree_add(tree,"CodingStandards.html");
  604.     HTBTree_add(tree,"Copyright.txt");
  605.     HTBTree_add(tree,"Status_old.html");
  606.     HTBTree_add(tree,"patches~");
  607.     HTBTree_add(tree,"RelatedProducts.html");
  608.     HTBTree_add(tree,"Implementation");
  609.     HTBTree_add(tree,"History.html");
  610.     HTBTree_add(tree,"Makefile.bak");
  611.     HTBTree_add(tree,"Makefile.old");
  612.     HTBTree_add(tree,"Policy.html");
  613.     HTBTree_add(tree,"WhatIs.html");
  614.     HTBTree_add(tree,"TheProject.html");
  615.     HTBTree_add(tree,"Notation.html");
  616.     HTBTree_add(tree,"Helping.html");
  617.     HTBTree_add(tree,"Cyber-WWW.sit.Hqx");
  618.     HTBTree_add(tree,"Glossary.html");
  619.     HTBTree_add(tree,"maketags.html");
  620.     HTBTree_add(tree,"IntroCS.html");
  621.     HTBTree_add(tree,"Contrib");
  622.     HTBTree_add(tree,"Help.html");
  623.     HTBTree_add(tree,"CodeManagExec");
  624.     HTBTree_add(tree,"HT-0.1draz");
  625.     HTBTree_add(tree,"Cello");
  626.     HTBTree_add(tree,"TOPUB");
  627.     HTBTree_add(tree,"BUILD");
  628.     HTBTree_add(tree,"BUILDALL");
  629.     HTBTree_add(tree,"Lynx");
  630.     HTBTree_add(tree,"ArthurLibrary");
  631.     HTBTree_add(tree,"RashtyClient");
  632.     HTBTree_add(tree,"#History.html#");
  633.     HTBTree_add(tree,"PerlServers");
  634.     HTBTree_add(tree,"modules");
  635.     HTBTree_add(tree,"NCSA_httpd");
  636.     HTBTree_add(tree,"MAIL2HTML");
  637.     HTBTree_add(tree,"core");
  638.     HTBTree_add(tree,"EmacsWWW");
  639. #ifdef BTREE_TRACE
  640.     printf("\nTreeTopObject=%s\n\n",tree->top->object);
  641. #endif
  642.     next_element = HTBTree_next(tree,NULL);
  643.     while (next_element != NULL)
  644.     {
  645. #ifndef BTREE_TRACE
  646.         printf("The next element is %s\n",next_element->object);
  647. #endif
  648.         next_element = HTBTree_next(tree,next_element);
  649.     }
  650.     HTBTree_free (tree);
  651. }
  652.  
  653.  
  654. #endif
  655.