Linked Representation of queues

 

Linked Representation of queues

We have seen how a queue is created using an array. Although this technique of creating a queue is easy, its drawback is that array must be declared to have some fixed size. the array implementation can not be used for large-scale applications where the queues are implemented. One of the alternatives to array implementation is the linked list implementation of a queue.

The storage requirement of linked representation of a queue with n elements is o(n) while the time required for operations is o(1).

In a linked queue, each node of the queue consists of two parts i.e. data part and the linked part. Each element of the queue points to its immediate next element in the memory.

There are two pointers maintained in the memory in the linked queue, i.e. front pointer and rear pointer. The front pointer contains the address of the starting element of the queue while the rear pointer contains the address of the last element of the queue.

Insertion and deletions are performed at the rear and front end respectively. If the front and rear both are NULL, it indicates that the queue is empty.

savagecoder



Operation on Linked Queue
Insert operation

Ptr = (struct node *) malloc (sizeof(struct node));  
ptr -> data = item;  
        if(front == NULL)  
        {  
            front = ptr;  
            rear = ptr;    
            front -> next = NULL;  
            rear -> next = NULL;  
        }  
In the second case, the queue contains more than one element. The condition front = NULL becomes false. In this scenario, we need to update the end pointer rear so that the next pointer of the rear will point to the new node ptr. Since this is a linked queue, hence we also need to make the rear pointer point to the newly added node ptr. We also need to make the next pointer of the rear point NULL.
           rear -> next = ptr;  
            rear = ptr;  
            rear->next = NULL;  
Algorithm
Step 1: Allocate the space for the new node PTR
Step 2: SET PTR -> DATA = VAL
Step 3: IF FRONT = NULL
SET FRONT = REAR = PTR
SET FRONT -> NEXT = REAR -> NEXT = NULL
ELSE
SET REAR -> NEXT = PTR
SET REAR = PTR
SET REAR -> NEXT = NULL
[END OF IF]
Step 4: END
C Function
  1. void insert(struct node *ptr, int item; )  
  1. {  
  1.       
  1.       
  1.     ptr = (struct node *) malloc (sizeof(struct node));  
  1.     if(ptr == NULL)  
  1.     {  
  1.         printf("\nOVERFLOW\n");  
  1.         return;  
  1.     }  
  1.     else  
  1.     {   
  1.         ptr -> data = item;  
  1.         if(front == NULL)  
  1.         {  
  1.             front = ptr;  
  1.             rear = ptr;   
  1.             front -> next = NULL;  
  1.             rear -> next = NULL;  
  1.         }  
  1.         else   
  1.         {  
  1.             rear -> next = ptr;  
  1.             rear = ptr;  
  1.             rear->next = NULL;  
  1.         }  
  1.     }  
  1. }     
Deletion

Deletion operation removes the element that is first inserted among all the queue elements. Firstly, we need to check either the list is empty or not. The condition front == NULL becomes true if the list is empty, in this case, we simply write underflow on the console and make exit.

Otherwise, we will delete the element that is pointed by the pointer front. For this purpose, copy the node pointed by the front pointer into the pointer ptr. Now, shift the front pointer, point to its next node, and free the node pointed by the node ptr. This is done by using the following statements.

ptr = front;  
        front = front -> next;  
        free(ptr);  
Algorithm
Step 1: IF FRONT = NULL
Write " Underflow "
Go to Step 5
[END OF IF]
Step 2: SET PTR = FRONT
Step 3: SET FRONT = FRONT -> NEXT
Step 4: FREE PTR
Step 5: END
C Function
  1. void delete (struct node *ptr)  
  1. {  
  1.     if(front == NULL)  
  1.     {  
  1.         printf("\nUNDERFLOW\n");  
  1.         return;  
  1.     }  
  1.     else   
  1.     {  
  1.         ptr = front;  
  1.         front = front -> next;  
  1.         free(ptr);  
  1.     }  
  1. }   
Menu-Driven Program implementing all the operations on Linked Queue
  1. #include<stdio.h>   
  1. #include<stdlib.h>  
  1. struct node   
  1. {  
  1.     int data;   
  1.     struct node *next;  
  1. };  
  1. struct node *front;  
  1. struct node *rear;   
  1. void insert();  
  1. void delete();  
  1. void display();  
  1. void main ()  
  1. {  
  1.     int choice;   
  1.     while(choice != 4)   
  1.     {     
  1.         printf("\n*************************Main Menu*****************************\n");  
  1.         printf("\n=================================================================\n");  
  1.         printf("\n1.insert an element\n2.Delete an element\n3.Display the queue\n4.Exit\n");  
  1.         printf("\nEnter your choice ?");  
  1.         scanf("%d",& choice);  
  1.         switch(choice)  
  1.         {  
  1.             case 1:  
  1.             insert();  
  1.             break;  
  1.             case 2:  
  1.             delete();  
  1.             break;  
  1.             case 3:  
  1.             display();  
  1.             break;  
  1.             case 4:  
  1.             exit(0);  
  1.             break;  
  1.             default:   
  1.             printf("\nEnter valid choice??\n");  
  1.         }  
  1.     }  
  1. }  
  1. void insert()  
  1. {  
  1.     struct node *ptr;  
  1.     int item;   
  1.       
  1.     ptr = (struct node *) malloc (sizeof(struct node));  
  1.     if(ptr == NULL)  
  1.     {  
  1.         printf("\nOVERFLOW\n");  
  1.         return;  
  1.     }  
  1.     else  
  1.     {   
  1.         printf("\nEnter value?\n");  
  1.         scanf("%d",&item);  
  1.         ptr -> data = item;  
  1.         if(front == NULL)  
  1.         {  
  1.             front = ptr;  
  1.             rear = ptr;   
  1.             front -> next = NULL;  
  1.             rear -> next = NULL;  
  1.         }  
  1.         else   
  1.         {  
  1.             rear -> next = ptr;  
  1.             rear = ptr;  
  1.             rear->next = NULL;  
  1.         }  
  1.     }  
  1. }     
  1. void delete ()  
  1. {  
  1.     struct node *ptr;  
  1.     if(front == NULL)  
  1.     {  
  1.         printf("\nUNDERFLOW\n");  
  1.         return;  
  1.     }  
  1.     else   
  1.     {  
  1.         ptr = front;  
  1.         front = front -> next;  
  1.         free(ptr);  
  1.     }  
  1. }  
  1. void display()  
  1. {  
  1.     struct node *ptr;  
  1.     ptr = front;      
  1.     if(front == NULL)  
  1.     {  
  1.         printf("\nEmpty queue\n");  
  1.     }  
  1.     else  
  1.     {   printf("\nprinting values .....\n");  
  1.         while(ptr != NULL)   
  1.         {  
  1.             printf("\n%d\n",ptr -> data);  
  1.             ptr = ptr -> next;  
  1.         }  
  1.     }  
  1. }  
**********Main Menu**********
==============================
1.insert an element
2.Delete an element
3.Display the queue
4.Exit
Enter your choice ? 1
Enter value?
123
***********Main Menu**********
==============================
1.insert an element
2.Delete an element
3.Display the queue
4.Exit
Enter your choice ?1
Enter value?
90
***********Main Menu**********
==============================
1.insert an element
2.Delete an element
3.Display the queue
4.Exit
Enter your choice ?3
printing values .....
123
90
***********Main Menu**********
==============================
1.insert an element
2.Delete an element
3.Display the queue
4.Exit
Enter your choice ?2
***********Main Menu**********
==============================
1.insert an element
2.Delete an element
3.Display the queue
4.Exit
Enter your choice ?3
printing values .....
90
***********Main Menu**********
==============================
1.insert an element
2.Delete an element
3.Display the queue
4.Exit


Enter your choice ?4

Comments

Post a Comment

Popular posts from this blog

LINEAR DATA STRUCTURE : STACK

Image
 What is a stack? A stack is a linear data structure in which the addition and deletion of data are done from the same end. This end is often referred to as the top of a stack. Last-In-First-Out (LIFO) structure. STACK ADT: DATA: It is a finite sequence of elements of a particular type. (arrays / linked list) OPERATIONS: 1. Initialize a stack. 2. check whether the stack is empty. 3. check whether the stack is full. 4. Insert at the top of stack if a stack is not full. This operation is called Push. 5. Delete a element from the top of stack if it is not empty. This operation is called Pop. 6. Retrieve an element from the top of stack. This operation is called Peek. STACK OPERATION Implementation of Stack: 1. Using Array 2. Using Linked List. Message Passing Methods in C: 1. Pass by Value / Call by Value. 2. Pass by Address / Call by Address. Implementation of a stack using arrays #include<stdio.h>   //pre-processor directive #include<unistd.h> #define MAX 5 str...
Read more