home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 3 / CDASC03.ISO / sorties / 4140 / whois_.exe / SLLIST.CPP < prev    next >
Text File  |  1991-08-20  |  6KB  |  265 lines
  1. /****************************************************************
  2. File Name:        sllist.cpp
  3. Author:            Andrew Frantz
  4. Purpose:            singly linked list(queue) function source
  5. Date:                2/8/91
  6. Environ:            BORLAND C++ v2.0
  7. Keywrd(s):        CPP SINGLY LINKED LIST
  8. ****************************************************************/
  9. #include "sllist.hpp"
  10. #include <string.h>
  11.  
  12. // ===============================================================
  13. node *sllist::add_queue(char *fname)
  14. {
  15.     node *scan = head;
  16.     node *old = NULL;
  17.  
  18.     if(!head)         // if no list create list
  19.     {
  20.         node *temp = new node;
  21.         temp->next = NULL;
  22.         strcpy(temp->file_name,fname);
  23.         head = temp;
  24.         return temp;
  25.     }
  26.  
  27.     scan = head;
  28.  
  29.     while(scan)       // traverse list
  30.     {
  31.         old = scan;                    // save previous
  32.          scan = (node *) scan->next;        // next item
  33.     }
  34.  
  35.     // append to end of list
  36.  
  37.     node *temp = new node;
  38.     scan = old;                            // restore previous
  39.     scan->next = temp;
  40.     strcpy(temp->file_name , fname);
  41.     temp->next = NULL;
  42.     return temp;
  43. }
  44. // ===============================================================
  45. node *sllist::add_queue(int c)
  46. {
  47.     node *scan = head;
  48.     node *old = NULL;
  49.  
  50.     if(!head)         // if no list create list
  51.     {
  52.         node *temp = new node;
  53.         temp->next = NULL;
  54.         temp->rec_num = c;
  55.         head = temp;
  56.         return temp;
  57.     }
  58.  
  59.     scan = head;
  60.     
  61.     while(scan)       // traverse list
  62.     {
  63.         if(c == scan->rec_num)
  64.         {
  65.             return NULL;       // item already in list
  66.         }
  67.         old = scan;                    // save previous
  68.          scan = (node *) scan->next;        // next item
  69.     }
  70.  
  71.     // append to end of list
  72.  
  73.     node *temp = new node;
  74.     scan = old;                            // restore previous
  75.     scan->next = temp;
  76.     temp->rec_num = c;
  77.     temp->next = NULL;
  78.     return temp;
  79. }
  80. // ===============================================================
  81. void sllist::add_in_p_order(int c)
  82. {
  83.     node *scan = head;
  84.     node *old = NULL;
  85.  
  86.     if(!head)         // if no list create list
  87.     {
  88.         node *temp = new node;
  89.         temp->next = NULL;
  90.         temp->rec_num = c;
  91.         head = temp;
  92.         return;
  93.     }
  94.  
  95.     scan = head;
  96.     if(c < scan->rec_num)        // put item at head of list
  97.     {
  98.         node *temp = new node;        // create space for a new node
  99.         temp->next = scan;
  100.         temp->rec_num = c;        // put in data
  101.         head = temp;
  102.         return;
  103.     }
  104.     else
  105.     {
  106.         while(scan)       // traverse list
  107.         {
  108.             if(c < scan->rec_num)
  109.             {
  110.                 node *temp = new node;        // create space for a new node
  111.                 temp->next = scan;            // link to the list
  112.                 temp->rec_num = c;        // put in data
  113.                 old->next = temp;                // backward patch
  114.                 return;                            // bye
  115.             }
  116.             old = scan;                   // save last  scan
  117.             scan = (node *) scan->next;        // next item
  118.         }
  119.     }
  120.     // append to end of list
  121.  
  122.     node *temp = new node;
  123.     scan = old;
  124.     scan->next = temp;
  125.     temp->rec_num = c;
  126.     temp->next = NULL;
  127. }
  128. // ==========================================================
  129. void sllist::del_one(int c)
  130. {
  131.     node *scan=head;
  132.     node *old = NULL;
  133.  
  134.     if(scan->rec_num == c)                // first item in list
  135.     {
  136.         head = (node *) scan->next;
  137.         delete scan;
  138.         return;
  139.     }
  140.     while(scan)       // traverse list
  141.     {
  142.         if(c == scan->rec_num)
  143.         {
  144.             old->next = (node *) scan->next;
  145.             delete scan;
  146.             return;                            // bye
  147.         }
  148.         old = scan;             // save last  scan
  149.         scan = (node *) scan->next;        // next item
  150.     }
  151. }
  152. // ==========================================================
  153. void sllist::del_all()
  154. {
  155.     node *temp = head;
  156.     
  157.     while(temp)
  158.     {
  159.         temp=head;
  160.         head=(node *) temp->next;
  161.         delete temp;                         // free up node
  162.     }
  163.     head=NULL;
  164. }
  165. // ==========================================================
  166. void sllist::print_list()
  167. {
  168.     node *temp = head;
  169.     int x=1;
  170.  
  171.     while(temp)
  172.     {
  173.         printf(" %s\n", temp->file_name);
  174.         if(!(x % 20))
  175.         {
  176.             x=0;
  177.             printf("\n");
  178.         }
  179.         x++;
  180.         temp=(node *) temp->next;
  181.     }
  182.     printf("\nSlist printed\n");
  183. }
  184. // ===============================================================
  185. void sllist::push_stack(int rec_num, int edge)
  186. {
  187.  
  188.     if(!head)         // if no list create list
  189.     {
  190.         node *temp = new node;
  191.         temp->next = NULL;
  192.         temp->rec_num = rec_num;
  193.         temp->edge = edge;
  194.         head = temp;
  195.         return;
  196.     }
  197.  
  198.     // push item to head of list
  199.  
  200.     node *temp = new node;        // create space for a new node
  201.     temp->rec_num = rec_num;        // put in data
  202.     temp->edge = edge;        // put in data
  203.     temp->next=head;            // next points to what head is currently at
  204.     head = temp;
  205.     return;
  206. }
  207. // ===============================================================
  208. int sllist::pop_stack(int *redge)
  209. {
  210.     node *scan=head;
  211.     node *old=head;
  212.     int vertex=0;
  213.  
  214.     if(head)
  215.     {
  216.         printf("Popping Off Vert = %d edge = %d \n", scan->rec_num, scan->edge);
  217.         vertex=scan->rec_num;
  218.         *redge=scan->edge;
  219.         scan=(node *) scan->next;
  220.         head=scan;
  221.         delete old;
  222.         return(vertex);
  223.     }
  224. }
  225. // ==========================================================
  226. void sllist::print_stack()
  227. {
  228.     node *temp = head;
  229.  
  230.     while(temp)
  231.     {
  232.         printf(" Vertex = %d Edge = %d\n", temp->rec_num, temp->edge);
  233. //        getche();
  234.         temp=(node *) temp->next;
  235.     }
  236. }
  237. // ==========================================================
  238. int sllist::check_stack_for_cycle()
  239. {
  240.     node *temp = head;
  241.     int last_node;
  242.  
  243.     int first_edge = temp->edge;
  244.  
  245.     if(head)
  246.     {
  247.         while(temp)
  248.         {
  249.             if(temp->next == NULL)
  250.             {
  251.                 last_node=temp->rec_num;
  252.             }
  253.             temp=(node *) temp->next;
  254.         }
  255.         if(last_node == first_edge)
  256.             return(1); //cycle complete
  257.         else
  258.             return(0);
  259.     }
  260.     else
  261.         return(1);
  262. }
  263. // ==========================================================
  264. // =================== End of Listing =======================
  265.