Open in App
Not now

# Queue – Linked List Implementation

• Difficulty Level : Easy
• Last Updated : 12 Jan, 2023

In this article, the Linked List implementation of the queue data structure is discussed and implemented. Print ‘-1’ if the queue is empty.

Approach: To solve the problem follow the below idea:

we maintain two pointers, front, and rear. The front points to the first item of the queue and rear points to the last item.

• enQueue(): This operation adds a new node after the rear and moves the rear to the next node.
• deQueue(): This operation removes the front node and moves the front to the next node.

Follow the below steps to solve the problem:

• Create a class QNode with data members integer data and QNode* next
• A parameterized constructor that takes an integer x value as a parameter and sets data equal to x and next as NULL
• Create a class Queue with data members QNode front and rear
• Enqueue Operation with parameter x:
• Initialize QNode* temp with data = x
• If the rear is set to NULL then set the front and rear to temp and return(Base Case)
• Else set rear next to temp and then move rear to temp
• Dequeue Operation:
• If the front is set to NULL return(Base Case)
• Initialize QNode temp with front and set front to its next
• If the front is equal to NULL then set the rear to NULL
• Delete temp from the memory

Below is the Implementation of the above approach:

## C++

 // C++ program for the above approach   #include using namespace std;   struct QNode {     int data;     QNode* next;     QNode(int d)     {         data = d;         next = NULL;     } };   struct Queue {     QNode *front, *rear;     Queue() { front = rear = NULL; }       void enQueue(int x)     {           // Create a new LL node         QNode* temp = new QNode(x);           // If queue is empty, then         // new node is front and rear both         if (rear == NULL) {             front = rear = temp;             return;         }           // Add the new node at         // the end of queue and change rear         rear->next = temp;         rear = temp;     }       // Function to remove     // a key from given queue q     void deQueue()     {         // If queue is empty, return NULL.         if (front == NULL)             return;           // Store previous front and         // move front one node ahead         QNode* temp = front;         front = front->next;           // If front becomes NULL, then         // change rear also as NULL         if (front == NULL)             rear = NULL;           delete (temp);     } };   // Driver code int main() {       Queue q;     q.enQueue(10);     q.enQueue(20);     q.deQueue();     q.deQueue();     q.enQueue(30);     q.enQueue(40);     q.enQueue(50);     q.deQueue();     cout << "Queue Front : " << ((q.front != NULL) ? (q.front)->data : -1)<< endl;     cout << "Queue Rear : " << ((q.rear != NULL) ? (q.rear)->data : -1); } // This code is contributed by rathbhupendra

## C

 // A C program to demonstrate linked list based // implementation of queue #include #include   // A linked list (LL) node to store a queue entry struct QNode {     int key;     struct QNode* next; };   // The queue, front stores the front node of LL and rear // stores the last node of LL struct Queue {     struct QNode *front, *rear; };   // A utility function to create a new linked list node. struct QNode* newNode(int k) {     struct QNode* temp         = (struct QNode*)malloc(sizeof(struct QNode));     temp->key = k;     temp->next = NULL;     return temp; }   // A utility function to create an empty queue struct Queue* createQueue() {     struct Queue* q         = (struct Queue*)malloc(sizeof(struct Queue));     q->front = q->rear = NULL;     return q; }   // The function to add a key k to q void enQueue(struct Queue* q, int k) {     // Create a new LL node     struct QNode* temp = newNode(k);       // If queue is empty, then new node is front and rear     // both     if (q->rear == NULL) {         q->front = q->rear = temp;         return;     }       // Add the new node at the end of queue and change rear     q->rear->next = temp;     q->rear = temp; }   // Function to remove a key from given queue q void deQueue(struct Queue* q) {     // If queue is empty, return NULL.     if (q->front == NULL)         return;       // Store previous front and move front one node ahead     struct QNode* temp = q->front;       q->front = q->front->next;       // If front becomes NULL, then change rear also as NULL     if (q->front == NULL)         q->rear = NULL;       free(temp); }   // Driver code int main() {     struct Queue* q = createQueue();     enQueue(q, 10);     enQueue(q, 20);     deQueue(q);     deQueue(q);     enQueue(q, 30);     enQueue(q, 40);     enQueue(q, 50);     deQueue(q);     printf("Queue Front : %d \n", ((q->front != NULL) ? (q->front)->key : -1));     printf("Queue Rear : %d", ((q->rear != NULL) ? (q->rear)->key : -1));     return 0; }

## Java

 // Java program for linked-list implementation of queue   // A linked list (LL) node to store a queue entry class QNode {     int key;     QNode next;       // constructor to create a new linked list node     public QNode(int key)     {         this.key = key;         this.next = null;     } }   // A class to represent a queue // The queue, front stores the front node of LL and rear // stores the last node of LL class Queue {     QNode front, rear;       public Queue() { this.front = this.rear = null; }       // Method to add an key to the queue.     void enqueue(int key)     {           // Create a new LL node         QNode temp = new QNode(key);           // If queue is empty, then new node is front and         // rear both         if (this.rear == null) {             this.front = this.rear = temp;             return;         }           // Add the new node at the end of queue and change         // rear         this.rear.next = temp;         this.rear = temp;     }       // Method to remove an key from queue.     void dequeue()     {         // If queue is empty, return NULL.         if (this.front == null)             return;           // Store previous front and move front one node         // ahead         QNode temp = this.front;         this.front = this.front.next;           // If front becomes NULL, then change rear also as         // NULL         if (this.front == null)             this.rear = null;     } }   // Driver code public class Test {     public static void main(String[] args)     {         Queue q = new Queue();         q.enqueue(10);         q.enqueue(20);         q.dequeue();         q.dequeue();         q.enqueue(30);         q.enqueue(40);         q.enqueue(50);         q.dequeue();         System.out.println("Queue Front : " + ((q.front != null) ? (q.front).key : -1));         System.out.println("Queue Rear : " + ((q.rear != null) ? (q.rear).key : -1));     } } // This code is contributed by Gaurav Miglani

## Python3

 # Python3 program to demonstrate linked list # based implementation of queue   # A linked list (LL) node # to store a queue entry     class Node:       def __init__(self, data):         self.data = data         self.next = None   # A class to represent a queue   # The queue, front stores the front node # of LL and rear stores the last node of LL     class Queue:       def __init__(self):         self.front = self.rear = None       def isEmpty(self):         return self.front == None       # Method to add an item to the queue     def EnQueue(self, item):         temp = Node(item)           if self.rear == None:             self.front = self.rear = temp             return         self.rear.next = temp         self.rear = temp       # Method to remove an item from queue     def DeQueue(self):           if self.isEmpty():             return         temp = self.front         self.front = temp.next           if(self.front == None):             self.rear = None     # Driver Code if __name__ == '__main__':     q = Queue()     q.EnQueue(10)     q.EnQueue(20)     q.DeQueue()     q.DeQueue()     q.EnQueue(30)     q.EnQueue(40)     q.EnQueue(50)     q.DeQueue()     print("Queue Front : " + str(q.front.data if q.front != None else -1))     print("Queue Rear : " + str(q.rear.data if q.rear != None else -1))

## C#

 // C# program for linked-list // implementation of queue using System;   // A linked list (LL) node to // store a queue entry class QNode {     public int key;     public QNode next;       // constructor to create     // a new linked list node     public QNode(int key)     {         this.key = key;         this.next = null;     } }   // A class to represent a queue The queue, // front stores the front node of LL and // rear stores the last node of LL class Queue {     public QNode front, rear;       public Queue() { this.front = this.rear = null; }       // Method to add an key to the queue.     public void enqueue(int key)     {           // Create a new LL node         QNode temp = new QNode(key);           // If queue is empty, then new         // node is front and rear both         if (this.rear == null) {             this.front = this.rear = temp;             return;         }           // Add the new node at the         // end of queue and change rear         this.rear.next = temp;         this.rear = temp;     }       // Method to remove an key from queue.     public void dequeue()     {         // If queue is empty, return NULL.         if (this.front == null)             return;           // Store previous front and         // move front one node ahead         this.front = this.front.next;           // If front becomes NULL,         // then change rear also as NULL         if (this.front == null)             this.rear = null;     } }   // Driver code public class Test {     public static void Main(String[] args)     {         Queue q = new Queue();         q.enqueue(10);         q.enqueue(20);         q.dequeue();         q.dequeue();         q.enqueue(30);         q.enqueue(40);         q.enqueue(50);         q.dequeue();         Console.WriteLine("Queue Front : " + ((q.front != null) ? (q.front).key : -1));         Console.WriteLine("Queue Rear : " + ((q.rear != null) ? (q.rear).key : -1));     } }   // This code has been contributed by Rajput-Ji

## Javascript



Output

Queue Front : 40
Queue Rear : 50

Time Complexity: O(1), The time complexity of both operations enqueue() and dequeue() is O(1) as it only changes a few pointers in both operations
Auxiliary Space: O(1), The auxiliary Space of both operations enqueue() and dequeue() is O(1) as constant extra space is required

Related Article:
Introduction and Array Implementation of Queue

My Personal Notes arrow_drop_up
Related Articles