Open In App
Related Articles

# Queue – Linked List Implementation

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 codeint 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 entrystruct QNode {    int key;    struct QNode* next;}; // The queue, front stores the front node of LL and rear// stores the last node of LLstruct 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 queuestruct 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 qvoid 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 qvoid 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 codeint 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 entryclass 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 LLclass 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 codepublic 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 Codeif __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 queueusing System; // A linked list (LL) node to// store a queue entryclass 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 LLclass 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 codepublic 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