# Queue – Linked List Implementation

In the previous post, we introduced Queue and discussed array implementation. In this post, linked list implementation is discussed. The following two main operations must be implemented efficiently.

In a Queue data structure, we maintain two pointers, front and rear. The front points the first item of queue and rear points to last item.

enQueue() This operation adds a new node after rear and moves rear to the next node.

deQueue() This operation removes the front node and moves front to the next node.

## C++

 `#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); ` `    ``} ` `}; ` ` `  `// Driven Program ` `int` `main() ` `{ ` ` `  `    ``Queue q; ` `    ``q.enQueue(10); ` `    ``q.enQueue(20); ` `    ``q.deQueue(); ` `    ``q.deQueue(); ` `    ``q.enQueue(30); ` `    ``q.enQueue(40); ` `    ``q.enQueue(50); ` `    ``cout << ``"Queue Front : "` `<< (q.front)->data << endl; ` `    ``cout << ``"Queue Rear : "` `<< (q.rear)->data; ` `} ` `// 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 Program to test anove functions ` `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->key); ` `    ``printf``(``"Queue Rear : %d"``, q->rear->key); ` `    ``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 class ` `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.key); ` `        ``System.out.println(``"Queue Rear : "` `+ q.rear.key); ` `    ``} ` `} ` `// 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``)     ` `    ``print``(``"Queue Front "` `+` `str``(q.front.data)) ` `    ``print``(``"Queue Rear "` `+` `str``(q.rear.data)) ` `    `

## 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 { ` `    ``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 ` `        ``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(); ` `        ``Console.WriteLine(``"Queue Front : "` `+ q.front.key); ` `        ``Console.WriteLine(``"Queue Rear : "` `+ q.rear.key); ` `    ``} ` `} ` ` `  `// This code has been contributed by Rajput-Ji `

Output:

```Queue Front : 30
Queue Rear : 50
```

Time Complexity: Time complexity of both operations enqueue() and dequeue() is O(1) as we only change few pointers in both operations. There is no loop in any of the operations.