Thanks to visit codestin.com
Credit goes to www.geeksforgeeks.org

Queue - Linked List Implementation

Last Updated : 20 Sep, 2025

Try it on GfG Practice

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 <iostream>
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

Implementation of Queue using Linked List

Implementation of Queue using Linked List

Linked List Implementation of Queue in Python

K

Improve

Article Tags :

Explore