Linked list implementation of stack

Instead of using array, we can also use linked list to implement stack. Linked list allocates the memory dynamically. However, time complexity in both the scenario is same for all the operations i.e. push, pop and peek.
In linked list implementation of stack, the nodes are maintained non-contiguously in the memory. Each node contains a pointer to its immediate successor node in the stack. Stack is said to be overflown if the space left in the memory heap is not enough to create a node.


The top most node in the stack always contains null in its address field. Lets discuss the way in which, each operation is performed in linked list implementation of stack.

Adding a node to the stack (Push operation)

Adding a node to the stack is referred to as push operation. Pushing an element to a stack in linked list implementation is different from that of an array implementation. In order to push an element onto the stack, the following steps are involved.

1. Create a node first and allocate memory to it.
2. If the list is empty then the item is to be pushed as the start node of the list. This includes assigning value to the data part of the node and assign null to the address part of the node.
3. If there are some nodes in the list already, then we have to add the new element in the beginning of the list (to not violate the property of the stack). For this purpose, assign the address of the starting element to the address field of the new node and make the new node, the starting node of the list.
Time Complexity : o(1)

 


C implementation :

1. void push ()  
2. {  
3.     int val;  
4.     struct node *ptr =(struct node*)malloc(sizeof(struct node));   
5.     if(ptr == NULL)  
6.     {  
7.         printf("not able to push the element");   
8.     }  
9.     else   
10.     {  
11.         printf("Enter the value");  
12.         scanf("%d",&val);  
13.         if(head==NULL)  
14.         {         
15.             ptr->val = val;  
16.             ptr -> next = NULL;  
17.             head=ptr;  
18.         }   
19.         else   
20.         {  
21.             ptr->val = val;  
22.             ptr->next = head;  
23.             head=ptr;  
24.                
25.         }  
26.         printf("Item pushed");  
27.           
28.     }  
29. }  

Deleting a node from the stack (POP operation)

Deleting a node from the top of stack is referred to as pop operation. Deleting a node from the linked list implementation of stack is different from that in the array implementation. In order to pop an element from the stack, we need to follow the following steps :
1. Check for the underflow condition: The underflow condition occurs when we try to pop from an already empty stack. The stack will be empty if the head pointer of the list points to null.
2. Adjust the head pointer accordingly: In stack, the elements are popped only from one end, therefore, the value stored in the head pointer must be deleted and the node must be freed. The next node of the head node now becomes the head node.
Time Complexity : o(n)

C implementation

1. void pop()  
2. {  
3.     int item;  
4.     struct node *ptr;  
5.     if (head == NULL)  
6.     {  
7.         printf("Underflow");  
8.     }  
9.     else  
10.     {  
11.         item = head->val;  
12.         ptr = head;  
13.         head = head->next;  
14.         free(ptr);  
15.         printf("Item popped");  
16.           
17.     }  
18. }  

Display the nodes (Traversing)

Displaying all the nodes of a stack needs traversing all the nodes of the linked list organized in the form of stack. For this purpose, we need to follow the following steps.
1. Copy the head pointer into a temporary pointer.
2. Move the temporary pointer through all the nodes of the list and print the value field attached to every node.
Time Complexity : o(n)

C Implementation

1. void display()  
2. {  
3.     int i;  
4.     struct node *ptr;  
5.     ptr=head;  
6.     if(ptr == NULL)  
7.     {  
8.         printf("Stack is empty\n");  
9.     }  
10.     else  
11.     {  
12.         printf("Printing Stack elements \n");  
13.         while(ptr!=NULL)  
14.         {  
15.             printf("%d\n",ptr->val);  
16.             ptr = ptr->next;  
17.         }  
18.     }  
19. }  

Menu Driven program in C implementing all the stack operations using linked list :

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. void push();  
4. void pop();  
5. void display();  
6. struct node   
7. {  
8. int val;  
9. struct node *next;  
10. };  
11. struct node *head;  
12.   
13. void main ()  
14. {  
15.     int choice=0;     
16.     printf("\n*********Stack operations using linked list*********\n");  
17.     printf("\n----------------------------------------------\n");  
18.     while(choice != 4)  
19.     {  
20.         printf("\n\nChose one from the below options...\n");  
21.         printf("\n1.Push\n2.Pop\n3.Show\n4.Exit");  
22.         printf("\n Enter your choice \n");        
23.         scanf("%d",&choice);  
24.         switch(choice)  
25.         {  
26.             case 1:  
27.             {   
28.                 push();  
29.                 break;  
30.             }  
31.             case 2:  
32.             {  
33.                 pop();  
34.                 break;  
35.             }  
36.             case 3:  
37.             {  
38.                 display();  
39.                 break;  
40.             }  
41.             case 4:   
42.             {  
43.                 printf("Exiting....");  
44.                 break;   
45.             }  
46.             default:  
47.             {  
48.                 printf("Please Enter valid choice ");  
49.             }   
50.     };  
51. }  
52. }  
53. void push ()  
54. {  
55.     int val;  
56.     struct node *ptr = (struct node*)malloc(sizeof(struct node));   
57.     if(ptr == NULL)  
58.     {  
59.         printf("not able to push the element");   
60.     }  
61.     else   
62.     {  
63.         printf("Enter the value");  
64.         scanf("%d",&val);  
65.         if(head==NULL)  
66.         {         
67.             ptr->val = val;  
68.             ptr -> next = NULL;  
69.             head=ptr;  
70.         }   
71.         else   
72.         {  
73.             ptr->val = val;  
74.             ptr->next = head;  
75.             head=ptr;  
76.                
77.         }  
78.         printf("Item pushed");  
79.           
80.     }  
81. }  
82.   
83. void pop()  
84. {  
85.     int item;  
86.     struct node *ptr;  
87.     if (head == NULL)  
88.     {  
89.         printf("Underflow");  
90.     }  
91.     else  
92.     {  
93.         item = head->val;  
94.         ptr = head;  
95.         head = head->next;  
96.         free(ptr);  
97.         printf("Item popped");  
98.           
99.     }  
100. }  
101. void display()  
102. {  
103.     int i;  
104.     struct node *ptr;  
105.     ptr=head;  
106.     if(ptr == NULL)  
107.     {  
108.         printf("Stack is empty\n");  
109.     }  
110.     else  
111.     {  
112.         printf("Printing Stack elements \n");  
113.         while(ptr!=NULL)  
114.         {  
115.             printf("%d\n",ptr->val);  
116.             ptr = ptr->next;  
117.         }  
118.     }  
119. }