Queue - Linked List Implementation
Last Updated :
25 Mar, 2025
Improve
Try it on GfG Practice 
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 Node with data members integer data and Node* 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 Node front and rear
- Enqueue Operation with parameter x:
- Initialize Node* 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 Node 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:
#include <iostream>
using namespace std;
// Node class definition
class Node {
public:
int data;
Node* next;
Node(int new_data) {
data = new_data;
next = nullptr;
}
};
// Queue class definition
class Queue {
private:
Node* front;
Node* rear;
public:
Queue() {
front = rear = nullptr;
}
// Function to check if the queue is empty
bool isEmpty() {
return front == nullptr;
}
// Function to add an element to the queue
void enqueue(int new_data) {
Node* new_node = new Node(new_data);
if (isEmpty()) {
front = rear = new_node;
printQueue();
return;
}
rear->next = new_node;
rear = new_node;
printQueue();
}
// Function to remove an element from the queue
void dequeue() {
if (isEmpty()) {
return;
}
Node* temp = front;
front = front->next;
if (front == nullptr) rear = nullptr;
delete temp;
printQueue();
}
// Function to print the current state of the queue
void printQueue() {
if (isEmpty()) {
cout << "Queue is empty" << endl;
return;
}
Node* temp = front;
cout << "Current Queue: ";
while (temp != nullptr) {
cout << temp->data << " ";
temp = temp->next;
}
cout << endl;
}
};
// Driver code to test the queue implementation
int main() {
Queue q;
// Enqueue elements into the queue
q.enqueue(10);
q.enqueue(20);
// Dequeue elements from the queue
q.dequeue();
q.dequeue();
// Enqueue more elements into the queue
q.enqueue(30);
q.enqueue(40);
q.enqueue(50);
// Dequeue an element from the queue (this should print 30)
q.dequeue();
return 0;
}
#include <stdio.h>
#include <stdlib.h>
// Node structure definition
struct Node {
int data;
struct Node* next;
};
// Queue structure definition
struct Queue {
struct Node* front;
struct Node* rear;
};
// Function to create a new node
struct Node* newNode(int new_data) {
struct Node* node = (struct Node*)malloc(sizeof(struct Node));
node->data = new_data;
node->next = NULL;
return node;
}
// Function to initialize the queue
struct Queue* createQueue() {
struct Queue* q = (struct Queue*)malloc(sizeof(struct Queue));
q->front = q->rear = NULL;
return q;
}
// Function to check if the queue is empty
int isEmpty(struct Queue* q) {
return q->front == NULL;
}
// Function to add an element to the queue
void enqueue(struct Queue* q, int new_data) {
struct Node* new_node = newNode(new_data);
if (isEmpty(q)) {
q->front = q->rear = new_node;
printQueue(q);
return;
}
q->rear->next = new_node;
q->rear = new_node;
printQueue(q);
}
// Function to remove an element from the queue
void dequeue(struct Queue* q) {
if (isEmpty(q)) {
return;
}
struct Node* temp = q->front;
q->front = q->front->next;
if (q->front == NULL) q->rear = NULL;
free(temp);
printQueue(q);
}
// Function to print the current state of the queue
void printQueue(struct Queue* q) {
if (isEmpty(q)) {
printf("Queue is empty\n");
return;
}
struct Node* temp = q->front;
printf("Current Queue: ");
while (temp != NULL) {
printf("%d ", temp->data);
temp = temp->next;
}
printf("\n");
}
// Driver code to test the queue implementation
int main() {
struct Queue* q = createQueue();
// Enqueue elements into the queue
enqueue(q, 10);
enqueue(q, 20);
// Dequeue elements from the queue
dequeue(q);
dequeue(q);
// Enqueue more elements into the queue
enqueue(q, 30);
enqueue(q, 40);
enqueue(q, 50);
// Dequeue an element from the queue (this should print 30)
dequeue(q);
return 0;
}
// Node class definition
class Node {
int data;
Node next;
Node(int new_data) {
data = new_data;
next = null;
}
}
// Queue class definition
class Queue {
private Node front;
private Node rear;
public Queue() {
front = rear = null;
}
// Function to check if the queue is empty
public boolean isEmpty() {
return front == null;
}
// Function to add an element to the queue
public void enqueue(int new_data) {
Node new_node = new Node(new_data);
if (isEmpty()) {
front = rear = new_node;
printQueue();
return;
}
rear.next = new_node;
rear = new_node;
printQueue();
}
// Function to remove an element from the queue
public void dequeue() {
if (isEmpty()) {
return;
}
Node temp = front;
front = front.next;
if (front == null) rear = null;
temp = null;
printQueue();
}
// Function to print the current state of the queue
public void printQueue() {
if (isEmpty()) {
System.out.println("Queue is empty");
return;
}
Node temp = front;
System.out.print("Current Queue: ");
while (temp != null) {
System.out.print(temp.data + " ");
temp = temp.next;
}
System.out.println();
}
}
// Driver code to test the queue implementation
public class Main {
public static void main(String[] args) {
Queue q = new Queue();
// Enqueue elements into the queue
q.enqueue(10);
q.enqueue(20);
// Dequeue elements from the queue
q.dequeue();
q.dequeue();
// Enqueue more elements into the queue
q.enqueue(30);
q.enqueue(40);
q.enqueue(50);
// Dequeue an element from the queue (this should print 30)
q.dequeue();
}
}
class Node:
def __init__(self, new_data):
self.data = new_data
self.next = None
class Queue:
def __init__(self):
self.front = self.rear = None
# Function to check if the queue is empty
def isEmpty(self):
return self.front is None
# Function to add an element to the queue
def enqueue(self, new_data):
new_node = Node(new_data)
if self.isEmpty():
self.front = self.rear = new_node
self.printQueue()
return
self.rear.next = new_node
self.rear = new_node
self.printQueue()
# Function to remove an element from the queue
def dequeue(self):
if self.isEmpty():
return
temp = self.front
self.front = self.front.next
if self.front is None:
self.rear = None
self.printQueue()
# Function to print the current state of the queue
def printQueue(self):
if self.isEmpty():
print("Queue is empty")
return
temp = self.front
queue_string = "Current Queue: "
while temp is not None:
queue_string += str(temp.data) + " "
temp = temp.next
print(queue_string)
q = Queue()
# Enqueue elements into the queue
q.enqueue(10)
q.enqueue(20)
# Dequeue elements from the queue
q.dequeue()
q.dequeue()
# Enqueue more elements into the queue
q.enqueue(30)
q.enqueue(40)
q.enqueue(50)
# Dequeue an element from the queue
q.dequeue()
// Node class
class Node {
constructor(new_data) {
this.data = new_data;
this.next = null;
}
}
// Queue class
class Queue {
constructor() {
this.front = this.rear = null;
}
// Function to check if the queue is empty
isEmpty() {
return this.front === null;
}
// Function to add an element to the queue
enqueue(new_data) {
const new_node = new Node(new_data);
if (this.isEmpty()) {
this.front = this.rear = new_node;
this.printQueue();
return;
}
this.rear.next = new_node;
this.rear = new_node;
this.printQueue();
}
// Function to remove an element from the queue
dequeue() {
if (this.isEmpty()) {
return;
}
const temp = this.front;
this.front = this.front.next;
if (this.front === null) {
this.rear = null;
}
this.printQueue();
}
// Function to print the current state of the queue
printQueue() {
if (this.isEmpty()) {
console.log("Queue is empty");
return;
}
let temp = this.front;
let queue_string = "Current Queue: ";
while (temp !== null) {
queue_string += temp.data + " ";
temp = temp.next;
}
console.log(queue_string);
}
}
const q = new Queue();
// Enqueue elements into the queue
q.enqueue(10);
q.enqueue(20);
// Dequeue elements from the queue
q.dequeue();
q.dequeue();
// Enqueue more elements into the queue
q.enqueue(30);
q.enqueue(40);
q.enqueue(50);
// Dequeue an element from the queue
q.dequeue();
Output
Current Queue: 10 Current Queue: 10 20 Current Queue: 20 Queue is empty Current Queue: 30 Current Queue: 30 40 Current Queue: 30 40 50 Current Queue: 40 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:
Array Implementation of Queue
