C Program to Demonstrates a linked list for numbers.

How to write a C Program to Demonstrates a linked list for numbers in C Programming Language ?

This Program Demonstrates a linked list for numbers.

Solution:

1. /*Demonstrates a linked list for numbers.*/
2.  
3.  
4.  
5. #include "list-0.h"    // contain struct for the linked list
6. #include <stdio.h>
7. #include <cs50.h>    // special library for using getint to get numper from user insead of scanf
8. #include <stdlib.h>    // for malloc and free functions
9. #include <unistd.h>    // for sleep function
10.  
11. //node to determine the beginning of the list.
12. node* first = NULL;  
13.  
14. // prototypes
15. void delete(void);
16. void insert(void);
17. void search(void);
18. void traverse(void);
19.  
20.  
21. int main(void)
22. {
23.     int c;  //the numper of menue
24.     do
25.     {
26.         printf("\nmenu\n"
27.                "1-delete\n"
28.                "2-insert\n"
29.                "3-search\n"
30.                "4-traverse\n"
31.                "0-quit\n");
32.                
33.        // get the command
34.        printf("command: ");
35.        c = GetInt();
36.        
37.        // execute the command
38.        switch(c)
39.        {
40.            case 1: delete(); break;
41.            case 2: insert(); break;
42.            case 3: search(); break;
43.            case 4: traverse(); break;
44.        }
45.        
46.        
47.    }
48.    while( c != 0);
49.    
50.    // clear the hole list before exiting
51.    node* ptr = first;
52.    while ( ptr != NULL)
53.    {
54.        node* predptr = ptr;
55.        ptr = ptr->next;
56.        free(predptr);
57.    }
58.    return 0;
59. }
60.  
61. // searching a numper in the list
62. void search(void)
63. {
64.     printf("the numper please: ");
65.     int n = GetInt();
66.    
67.     // insitate a node for the search at the beginnig
68.     node* ptr = first;
69.    
70.     //continue searching until reach the end of  the list
71.     while ( ptr != NULL)
72.     {
73.        
74.         if( ptr->n == n)
75.         {
76.             printf("founded\n");
77.             break;
78.         }
79.        
80.         else
81.             // update the pounter
82.             ptr = ptr-> next;    
83.     }
84.    
85.     //if reached to the end of list
86.     if (ptr == NULL)
87.         printf("not founded\n");
88. }
89.  
90. void delete(void)
91. {
92.     printf("the numper please: ");
93.     int n = GetInt();
94.    
95.     // insitate a pointer at the beginning of the list
96.     node* ptr = first;
97.    
98.     //insitate to rememper the previous node in the list before deleting
99.     node* predptr = NULL;
100.     while( ptr != NULL)
101.     {
102.         if( ptr-> n == n)
103.         {
104.            
105.             // deleting the first node
106.             if( ptr == first)
107.             {
108.                 first = ptr-> next;
109.                 free(ptr);
110.             }
111.            
112.             //deleting from the middle or tail
113.             else
114.             {
115.               predptr->next = ptr->next;
116.               free(ptr);
117.              
118.             }
119.            
120.             break;
121.         }
122.        
123.         // update the pointers to the next of each
124.         else
125.         {
126.             predptr = ptr;          
127.             ptr = ptr-> next;
128.         }
129.     }
130.    
131.     // make the traverse process to print the list out
132.     traverse();
133. }
134.  
135. void traverse(void)
136. {
137.     node* ptr = first;
138.    
139.     //print all the list numbers
140.     printf("the list is: ");
141.     while ( ptr!= NULL)
142.     {
143.         printf("%i ", ptr->n);
144.         ptr = ptr->next;
145.     }
146.    
147.    
148.     // flush standard output since we haven't outputted any newlines yet
149.     fflush(stdout);
150.  
151.     // pause before continuing
152.     sleep(1);
153.     printf("\n\n");
154. }
155.  
156. // the hardest process :)..
157. void insert(void)
158. {
159.     // allocate memory for new insert strcuct
160.     node* insert = malloc(sizeof(node));
161.     if(insert == NULL)
162.     {
163.         printf("cann't allocated..!!\n");
164.         return;
165.     }
166.    
167.     // fill the node
168.     printf("\nthe numper please: ");
169.     insert->n = GetInt();
170.     insert->next = NULL;
171.    
172.     // insert at the beginning if the list empty
173.     if( first == NULL)
174.         first = insert;
175.        
176.     // if it is lower than the first numper
177.     else if ( insert->n < first->n )
178.     {
179.         insert->next = first;
180.         first = insert;
181.     }
182.    
183.     else
184.     {
185.         // to terverse the list for comparing the numpers
186.         node* ptr = first;
187.        
188.         while (true)
189.         {
190.             // insert in in the last if it is the beggist numper
191.             // must be before the down comparing or will generate "segemntaion fault"
192.             if ( ptr->next == NULL)
193.             {
194.                 ptr->next = insert;
195.                 break;
196.             }
197.            
198.             // attention please : ptr->next->n
199.             //at 'c' compare the next numper at 'e' to the inserting
200.             else if( insert-> n < ptr->next->n )
201.             {
202.                 insert-> next = ptr->next;
203.                 ptr->next = insert;
204.                 break;
205.             }        
206.            
207.             // always update the ptr to reverse the list until we insert the item
208.             ptr = ptr->next;  
209.         }
210.     }
211.     // make the traverse process to print the list out
212.     traverse();  
213.    
214. }

Learn More :

Share this

Share on FacebookPlus on Google+