Queue Linked List Implementation (original) (raw)

Last Updated : 20 Sep, 2025

A Queue is a linear data structure that follows the **First-In-First-Out (FIFO) principle. The element inserted first is the first one to be removed.
Queue-Linked-List-Implementation_

It can be implemented using a linked list, where each element of the queue is represented as a node.

Declaration of Queue using Linked List

To implement a queue with a linked list, we maintain:

A Node structure/class that contains:

data → to store the element.
next → pointer/reference to the next node in the queue.

Two pointers/references:

front → points to the first node (head of the queue).
rear → points to the last node (tail of the queue). C++ `

class Node { public: int data; Node* next; Node(int new_data) { data = new_data; next = nullptr; } };

// Queue class class myQueue { private: Node* front; Node* rear;

public: myQueue() { front = rear = nullptr; } };

C

// Node structure typedef struct Node { int data; struct Node* next; } Node;

// Queue structure typedef struct myQueue { Node* front; Node* rear; } myQueue;

Java

class Node { int data; Node next; Node(int new_data) { data = new_data; next = null; } }

// Queue class definition class myQueue { private Node front; private Node rear;

public myQueue() {
    front = rear = null;
}

};

Python

class Node: def init(self, new_data): self.data = new_data self.next = None

class myQueue: def init(self): self.front = None self.rear = None

C#

// Node class definition public class Node { public int data; public Node next; public Node(int new_data) { data = new_data; next = null; } }

// Queue class definition public class myQueue { private Node front; private Node rear;

public myQueue() {
    front = rear = null;
}

};

JavaScript

// Node class class Node { constructor(new_data) { this.data = new_data; this.next = null; } }

// Queue class class myQueue { constructor() { this.front = this.rear = null; } };

Operations on Queue using Linked List:

Enqueue Operation

The enqueue operation adds an element to the rear of the queue. Unlike array implementation, there is no fixed capacity in linked list. Overflow occurs only when memory is exhausted.

A new node is created with the given value.
If the queue is empty (front == null and rear == null), both front and rear are set to this new node.
Otherwise, the current rear’s next pointer is set to the new node.
The rear pointer is updated to point to the new node. C++ `

void enqueue(int new_data) { Node* node = new Node(new_data); if (isEmpty()) { front = rear = node; } else { rear->next = node; rear = node; } }

C

void enqueue(Queue* q, int data) { Node* node = newNode(data); if (isEmpty(q)) { q->front = q->rear = node; } else { q->rear->next = node; q->rear = node; } }

Java

public void enqueue(int new_data) { Node new_node = new Node(new_data); if (isEmpty()) { front = rear = new_node; } else { rear.next = new_node; rear = new_node; } }

Python

def enqueue(self, new_data): new_node = Node(new_data) if self.isEmpty(): self.front = self.rear = new_node else: self.rear.next = new_node self.rear = new_node

C#

public void enqueue(int new_data) { Node new_node = new Node(new_data); if (isEmpty()) { front = rear = new_node; } else { rear.next = new_node; rear = new_node; } }

JavaScript

function enqueue(new_data) { const new_node = new Node(new_data); if (this.isEmpty()) { this.front = this.rear = new_node; } else { this.rear.next = new_node; this.rear = new_node; } }

**Time Complexity: O(1)
**Auxiliary Space: O(1)

Dequeue Operation

The dequeue operation removes an element from the front of the queue.

If the queue is empty (front == null), return underflow (queue is empty).
Otherwise, store the current front node in a temporary pointer.
Move the front pointer to the next node (front = front.next).
If the front becomes null, also set rear = null (queue becomes empty). C++ `

// Dequeue int dequeue() { if (isEmpty()) { cout << "Queue Underflow" << endl; return -1; }

   Node* temp = front;
   int removedData = temp->data;
   front= front->next;

   if (front == nullptr) rear = nullptr;
   delete temp;
   return removedData;

}

C

int dequeue(Queue* q) { if (isEmpty(q)) { printf("Queue Underflow\n"); return -1; }

Node* temp = q->front;
int removedData = temp->data;
q->front = q->front->next;

if (q->front == NULL) q->rear = NULL;
free(temp);

return removedData;

}

Java

public void dequeue() { if (isEmpty()) { System.out.println("Queue Underflow"); return; }

    Node temp = front;
    front = front.next;
    if (front == null) rear = null;
    temp = null; 
}

Python

def dequeue(self): if self.isEmpty(): print("Queue Underflow") return

temp = self.front
self.front = self.front.next
if self.front is None:
    self.rear = None

C#

public void dequeue() { if (isEmpty()) { System.Console.WriteLine("Queue Underflow"); return; }

Node temp = front;
front = front.next;
if (front == null)
    rear = null;

}

JavaScript

function dequeue() { if (this.isEmpty()) { console.log("Queue Underflow"); return; } this.front = this.front.next;

if (this.front === null) {
    this.rear = null;
}

}

**Time Complexity: O(1)
**Auxiliary Space: O(1)

Queue-Linked-List-Implementation_

isEmpty Operation

The isEmpty operation checks whether the queue has no elements.

If the front pointer is NULL, it means the queue is empty → return true.
Otherwise, the queue has elements → return false. C++ `

// Check if empty bool isEmpty() { return front == nullptr; }

C

// Check if the queue is empty int isEmpty(Queue* q) { return q->front == NULL; }

Java

// Check if the queue is empty public boolean isEmpty() { return front == null; }

Python

Check if the queue is empty

def isEmpty(self): return self.front is None

C#

// Check if the queue is empty public bool isEmpty() { return front == null; }

JavaScript

// Check if queue is empty function isEmpty() { return this.front === null; }

**Time Complexity: O(1)
**Auxiliary Space: O(1)

Front Operation

The front() function returns the element at the front of the queue without removing it.

If the queue is empty (front == NULL), print a message and return -1.
Otherwise, return front->data (the value at the front). C++ `

int getfront() { if (isEmpty()) { cout << "Queue is empty" << endl; return -1; } return front->data; }

C

int getfront(Queue* q) { if (isEmpty(q)) { printf("Queue is empty\n"); return -1; } return q->front->data; }

Java

// Return front element public int getfront() { if (isEmpty()) { System.out.println("Queue is empty"); return -1; } return front.data; }

Python

Return the front element

def getfront(self): if self.isEmpty(): print("Queue is empty") return -1 return self.front.data

C#

// Return front element public int getfront() { if (isEmpty()) { System.Console.WriteLine("Queue is empty"); return -1; } return front.data; }

JavaScript

// Return the front element function getfront() { if (this.isEmpty()) { console.log("Queue is empty"); return -1; } return this.front.data; }

**Time Complexity: O(1)
**Auxiliary Space: O(1)

Full Implementations of Queue Using Linked List

C++ `

#include using namespace std;

// Node class class Node { public: int data; Node* next; Node(int new_data) { data = new_data; next = nullptr; } };

// Queue class class myQueue { private: int currSize; Node* front; Node* rear;

public: myQueue() { currSize = 0; front = rear= nullptr; }

// Check if empty
bool isEmpty() {
    return front == nullptr;
}

// Enqueue
void enqueue(int new_data) {
    Node* node = new Node(new_data);
    if (isEmpty()) {
        front = rear = node;
    } else {
        rear->next = node;
        rear = node;
    }
    
    currSize++;
}

// Dequeue
int dequeue() {
    if (isEmpty()) {
        cout << "Queue Underflow" << endl;
        return -1;
    }
    
    Node* temp = front;
    int removedData = temp->data;
    front = front->next;
    
    if (front == nullptr) rear = nullptr;
    delete temp;
    
    currSize--;
    return removedData;
}

// Get front element
int getfront() {
    if (isEmpty()) {
        cout << "Queue is empty" << endl;
        return -1;
    }
    return front->data;
}

// Get size
int size() {
   return currSize;
}

};

int main() { myQueue q;

q.enqueue(10);
q.enqueue(20);

cout << "Dequeue: " << q.dequeue() << "\n";

q.enqueue(30);

cout << "Front: " << q.getfront() << endl;
cout << "Size: " << q.size() << endl;

return 0;

}

C

#include <stdio.h> #include <stdlib.h>

// Node structure typedef struct Node { int data; struct Node* next; } Node;

// myQueue structure typedef struct myQueue { int currSize; Node* front; Node* rear; } myQueue;

// Create a new node Node* newNode(int data) { Node* node = (Node*)malloc(sizeof(Node)); node->data = data; node->next = NULL; return node; }

// Create an empty queue myQueue* createQueue() { myQueue* q = (myQueue*)malloc(sizeof(myQueue)); q->front = q->rear = NULL; q->currSize = 0; return q; }

// Check if the queue is empty int isEmpty(myQueue* q) { return q->front == NULL; }

// Enqueue operation void enqueue(myQueue* q, int data) { Node* node = newNode(data); if (isEmpty(q)) { q->front = q->rear = node; } else { q->rear->next = node; q->rear = node; }

q->currSize++;

}

// Dequeue operation int dequeue(myQueue* q) { if (isEmpty(q)) { printf("Queue Underflow\n"); return -1; }

Node* temp = q->front;
int removedData = temp->data;
q->front = q->front->next;
if (q->front == NULL) q->rear = NULL;
free(temp);

q->currSize--;
return removedData;

}

// Get front element int getFront(myQueue* q) { if (isEmpty(q)) { printf("Queue is empty\n"); return -1; } return q->front->data; }

// Get queue size int size(myQueue* q) { return q->currSize; }

int main() { myQueue* q = createQueue();

enqueue(q, 10);
enqueue(q, 20);

printf("Dequeue: %d\n",dequeue(q));

enqueue(q, 30);

printf("Front: %d\n", getFront(q));
printf("Size: %d\n", size(q));

return 0;

}

Java

// Node class definition class Node { int data; Node next; Node(int new_data) { data = new_data; next = null; } }

// Queue class definition class myQueue { private Node front; private Node rear; private int currSize;

public myQueue() {
    currSize = 0;
    front = rear = null;
}

// Check if the queue is empty
public boolean isEmpty() {
    return front == null;
}

// Enqueue operation
public void enqueue(int new_data) {
    Node new_node = new Node(new_data);
    if (isEmpty()) {
        front = rear = new_node;
    } else {
        rear.next = new_node;
        rear = new_node;
    }
    
    currSize++;
}

// Dequeue operation (returns removed element)
public int dequeue() {
    if (isEmpty()) {
        System.out.println("Queue Underflow");
        return -1;
    }
    Node temp = front;
    int removedData = temp.data;
    front = front.next;
    if (front == null) rear = null;

    currSize--;
    return removedData;
}

// Return front element
public int getfront() {
    if (isEmpty()) {
        System.out.println("Queue is empty");
        return -1;
    }
    return front.data;
}

// Return size of the queue
public int size() {
    return currSize;
}

}

class GFG { public static void main(String[] args) { myQueue q = new myQueue();

    q.enqueue(10);
    q.enqueue(20);

    System.out.println("Dequeue: " + q.dequeue());

    q.enqueue(30);

    System.out.println("Front: " + q.getfront());
    System.out.println("Size: " + q.size());
}

}

Python

class Node: def init(self, new_data): self.data = new_data self.next = None

class myQueue: def init(self): self.front = None self.rear = None self.currSize = 0

# Check if the queue is empty
def isEmpty(self):
    return self.front is None

# Add element to the queue
def enqueue(self, new_data):
    new_node = Node(new_data)
    if self.isEmpty():
        self.front = self.rear = new_node
    else:
        self.rear.next = new_node
        self.rear = new_node
        
    # increment size
    self.currSize += 1 

# Remove element from the queue and return it
def dequeue(self):
    if self.isEmpty():
        print("Queue Underflow")
        return -1
    removedData = self.front.data
    self.front = self.front.next
    if self.front is None:
        self.rear = None
        
    # decrement size
    self.currSize -= 1 
    return removedData

# Return the front element
def getfront(self):
    if self.isEmpty():
        print("Queue is empty")
        return -1
    return self.front.data

# Return size in O(1)
def size(self):
    return self.currSize

if name == "main": q = myQueue()

q.enqueue(10)
q.enqueue(20)

print("Dequeue:", q.dequeue())

q.enqueue(30)

print("Front:", q.getfront())
print("Size:", q.size())

C#

using System;

// Node class definition class Node { public int data; public Node next;

public Node(int new_data) {
    data = new_data;
    next = null;
}

}

// Queue class definition class myQueue { private Node front; private Node rear; private int currSize;

public myQueue() {
    front = rear = null;
    currSize = 0;
}

// Check if the queue is empty
public bool isEmpty() {
    return front == null;
}

// Enqueue operation
public void enqueue(int new_data) {
    Node new_node = new Node(new_data);
    if (isEmpty()) {
        front = rear = new_node;
    } else {
        rear.next = new_node;
        rear = new_node;
    }
    currSize++; 
}

// Dequeue operation (returns removed element)
public int dequeue() {
    if (isEmpty()) {
        Console.WriteLine("Queue Underflow");
        return -1;
    }
    int removedData = front.data;
    front = front.next;
    if (front == null) rear = null;
    currSize--; 
    return removedData;
}

// Return front element
public int getFront() {
    if (isEmpty()) {
        Console.WriteLine("Queue is empty");
        return -1;
    }
    return front.data;
}

// Return size in O(1)
public int size() {
    return currSize;
}

}

class GFG { public static void Main(string[] args) { myQueue q = new myQueue();

    q.enqueue(10);
    q.enqueue(20);

    Console.WriteLine("Dequeue: " + q.dequeue());

    q.enqueue(30);

    Console.WriteLine("Front: " + q.getFront());
    Console.WriteLine("Size: " + q.size());
}

}

JavaScript

// Node class class Node { constructor(new_data) { this.data = new_data; this.next = null; } }

// Queue class class myQueue { constructor() { this.front = this.rear = null; this.currSize = 0; }

// Check if queue is empty
isEmpty() {
    return this.front === null;
}

// Add element to the queue
enqueue(new_data) {
    const new_node = new Node(new_data);
    if (this.isEmpty()) {
        this.front = this.rear = new_node;
    } else {
        this.rear.next = new_node;
        this.rear = new_node;
    }
    this.currSize++; 
}

// Remove element from the queue and return it
dequeue() {
    if (this.isEmpty()) {
        console.log("Queue Underflow");
        return -1;
    }
    const removedData = this.front.data;
    this.front = this.front.next;
    if (this.front === null) {
        this.rear = null;
    }
    this.currSize--; 
    return removedData;
}

// Return the front element
getfront() {
    if (this.isEmpty()) {
        console.log("Queue is empty");
        return -1;
    }
    return this.front.data;
}

// Return the size of the queue in O(1)
size() {
    return this.currSize;
}

}

// Driver code const q = new myQueue();

q.enqueue(10); q.enqueue(20);

console.log("Dequeue:", q.dequeue());

q.enqueue(30);

console.log("Front:", q.getfront()); console.log("Size:", q.size());

Output

Dequeue: 10 Front: 20 Size: 2

Array Implementation of Queue

Queue Linked List Implementation (original) (raw)

Declaration of Queue using Linked List

Operations on Queue using Linked List:

Enqueue Operation

Dequeue Operation

isEmpty Operation

Check if the queue is empty

Front Operation

Return the front element

Full Implementations of Queue Using Linked List

Implementation of Queue using Linked List

Linked List Implementation of Queue in Python

Queue Linked List Implementation (original) (raw)

Declaration of Queue using Linked List

Operations on Queue using Linked List:

Enqueue Operation

Dequeue Operation

isEmpty Operation

Check if the queue is empty

Front Operation

Return the front element

Full Implementations of Queue Using Linked List

Related Article:

Implementation of Queue using Linked List

Linked List Implementation of Queue in Python