Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Queue – Linked List Implementation

  • Difficulty Level : Easy
  • Last Updated : 06 Aug, 2021

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 <bits/stdc++.h>
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);
    q.deQueue();
    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 <stdio.h>
#include <stdlib.h>
 
// 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)
    q.DeQueue()  
    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
Javascript



<script>
// JavaScript program for linked-list implementation of queue
class QNode
{
    constructor(key)
    {
        this.key = key;
        this.next = null;
    }
}
 
let front = null, rear = null;
 
function enqueue(key)
{
    // Create a new LL node
        let temp = new QNode(key);
   
        // 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 dequeue()
{
    // If queue is empty, return NULL.
        if (front == null)
            return;
   
        // Store previous front and move front one node ahead
        let temp = front;
        front = front.next;
   
        // If front becomes NULL, then change rear also as NULL
        if (front == null)
            rear = null;
}
 
 
enqueue(10);
enqueue(20);
dequeue();
dequeue();
enqueue(30);
enqueue(40);
enqueue(50);
dequeue();
document.write("Queue Front : " + front.key+"<br>");
document.write("Queue Rear : " + rear.key+"<br>");
 
 
// This code is contributed by avanitrachhadiya2155
</script>
Output: 
Queue Front : 40
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.
  
 
 
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
 

My Personal Notes
arrow_drop_up
Previous
Queue | Set 1 (Introduction and Array Implementation)
Next

Implement a stack using singly linked list
Recommended Articles
Page :
Circular Queue | Set 2 (Circular Linked List Implementation)
25, Apr 17
Stack and Queue in Python using queue Module
19, Jan 18
Difference between Circular Queue and Priority Queue
27, Aug 20
Difference Between Linear Queue and Circular Queue
06, Jan 21
Advantages of circular queue over linear queue
15, Mar 21
Reversing a Queue using another Queue
04, Sep 19
Check if a queue can be sorted into another queue using a stack
09, May 18
Array implementation of queue (Simple)
20, Nov 18
Queue | Set 1 (Introduction and Array Implementation)
01, Feb 14
Circular Queue | Set 1 (Introduction and Array Implementation)
06, Apr 17
Priority Queue using Doubly Linked List
01, Feb 18
Difference between a Static Queue and a Singly Linked List
20, Nov 18
Python | Queue using Doubly Linked List
31, Jul 19
Priority Queue using Linked List
29, Jan 18
Recursively Reversing a linked list (A simple implementation)
03, Oct 18
Linked List Implementation in C#
26, Mar 19
Implementation of Deque using doubly linked list
08, Dec 17
XOR Linked List - A Memory Efficient Doubly Linked List | Set 1
23, May 11
Convert singly linked list into circular linked list
22, Sep 17
Difference between Singly linked list and Doubly linked list
07, Jan 19
Create new linked list from two given linked list with greater element at each node
22, May 19
XOR Linked List: Remove last node of the Linked List
24, Feb 21
XOR linked list- Remove first node of the linked list
18, Jan 21
XOR Linked List - Reverse a Linked List in groups of given size
17, Jan 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!