 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