Enqueue Using Linked List in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after enqueuing elements in a linked list queue?

Consider a queue implemented using a linked list. Initially, the queue is empty. We enqueue the elements 5, 10, and 15 in that order. What will be the printed state of the queue after these operations?

DSA C#

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

class Queue {
    private Node front, rear;

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

    public void Enqueue(int item) {
        Node newNode = new Node(item);
        if (rear == null) {
            front = rear = newNode;
            return;
        }
        rear.next = newNode;
        rear = newNode;
    }

    public void PrintQueue() {
        Node temp = front;
        while (temp != null) {
            System.Console.Write(temp.data + " -> ");
            temp = temp.next;
        }
        System.Console.WriteLine("null");
    }
}

Queue q = new Queue();
q.Enqueue(5);
q.Enqueue(10);
q.Enqueue(15);
q.PrintQueue();

A 5 -> null

B 15 -> 10 -> 5 -> null

C null

D 5 -> 10 -> 15 -> null

💡 Hint

Remember that enqueue adds elements at the rear of the queue.

Enqueue adds elements at the rear. So the first element 5 is at front, then 10, then 15 at rear. The print shows from front to rear.

🧠 Conceptual

intermediate

What happens to the rear pointer after enqueue in a linked list queue?

In a linked list implementation of a queue, when you enqueue a new element, what happens to the rear pointer?

A It becomes null.

B It moves to point to the newly added node.

C It moves to point to the front node.

D It remains pointing to the old last node.

💡 Hint

Think about where the new element is added in the queue.

The rear pointer always points to the last node in the queue. After enqueue, it must update to the new node added at the end.

🔧 Debug

advanced

Identify the error in this enqueue method for linked list queue

What error will this enqueue method cause when called on an empty queue? public void Enqueue(int item) { Node newNode = new Node(item); rear.next = newNode; rear = newNode; if (front == null) { front = rear; } }

A NullReferenceException because rear is null when queue is empty.

B No error, code works fine.

C StackOverflowException due to infinite recursion.

D Compile-time error due to missing return statement.

💡 Hint

What happens if rear is null and you try to access rear.next?

If the queue is empty, rear is null. Trying to access rear.next causes NullReferenceException.

🚀 Application

advanced

After enqueuing and dequeuing, what is the queue state?

Given a linked list queue initially empty, we enqueue 1, 2, 3, then dequeue twice, then enqueue 4. What is the printed queue state?

DSA C#

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

class Queue {
    private Node front, rear;

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

    public void Enqueue(int item) {
        Node newNode = new Node(item);
        if (rear == null) {
            front = rear = newNode;
            return;
        }
        rear.next = newNode;
        rear = newNode;
    }

    public int Dequeue() {
        if (front == null) throw new System.InvalidOperationException("Queue is empty");
        int val = front.data;
        front = front.next;
        if (front == null) rear = null;
        return val;
    }

    public void PrintQueue() {
        Node temp = front;
        while (temp != null) {
            System.Console.Write(temp.data + " -> ");
            temp = temp.next;
        }
        System.Console.WriteLine("null");
    }
}

Queue q = new Queue();
q.Enqueue(1);
q.Enqueue(2);
q.Enqueue(3);
q.Dequeue();
q.Dequeue();
q.Enqueue(4);
q.PrintQueue();

A 3 -> 4 -> null

B 4 -> null

C 1 -> 2 -> 3 -> 4 -> null

D 2 -> 3 -> 4 -> null

💡 Hint

Dequeue removes from front, enqueue adds at rear.

After enqueue 1,2,3 queue is 1->2->3->null. Dequeue twice removes 1 and 2, queue is 3->null. Enqueue 4 adds at rear, queue is 3->4->null.

🧠 Conceptual

expert

Why is a linked list preferred over array for enqueue in a dynamic queue?

In implementing a queue that can grow dynamically, why might a linked list be preferred over an array for the enqueue operation?

A Because linked lists use less memory than arrays always.

B Because arrays cannot store integers.

C Because linked list enqueue is always O(1) without resizing, while array may need resizing causing O(n).

D Because arrays do not support enqueue operation.

💡 Hint

Think about what happens when an array is full and you try to add more elements.

Arrays have fixed size; when full, resizing is needed which takes O(n). Linked lists allocate nodes dynamically, so enqueue is always O(1).

Practice

1. What does the Enqueue operation do in a linked list implementation of a queue?

easy

A. Adds an element at the front of the linked list

B. Removes an element from the front of the linked list

C. Deletes the last element of the linked list

D. Adds an element at the end of the linked list

Solution

1. Step 1: Understand enqueue operation

   Enqueue means adding an element to the queue.

2. Step 2: Identify linked list behavior for enqueue

   In a linked list queue, enqueue adds the new node at the end (tail).

3. Final Answer:

   Adds an element at the end of the linked list -> Option D

4. Quick Check:

   Enqueue = Add at tail [OK]

Hint: Enqueue always adds at the tail in linked list queue [OK]

Common Mistakes:

• Confusing enqueue with dequeue operation
• Adding element at the front instead of the end
• Thinking enqueue removes elements

2. Which of the following is the correct syntax to create a new node and enqueue it in a linked list queue in C#?

easy

A. Node newNode = new Node(data); tail.next = newNode; tail = newNode;

B. Node newNode = Node(data); tail.next = newNode; tail = newNode;

C. Node newNode = new Node(); tail = newNode; tail.next = data;

D. Node newNode = new Node(data); head.next = newNode; head = newNode;

Solution

1. Step 1: Create new node with data

   Use 'new Node(data)' to create a node with the given data.

2. Step 2: Link new node at tail and update tail

   Set 'tail.next = newNode' and then update 'tail = newNode' to keep tail at last node.

3. Final Answer:

   Node newNode = new Node(data); tail.next = newNode; tail = newNode; -> Option A

4. Quick Check:

   Correct node creation and tail update [OK]

Hint: Use 'new' keyword and update tail pointer [OK]

Common Mistakes:

• Forgetting 'new' keyword when creating node
• Updating head instead of tail
• Assigning data to next pointer

3. What will be the state of the queue after executing the following C# code?

QueueLinkedList queue = new QueueLinkedList();
queue.Enqueue(10);
queue.Enqueue(20);
queue.Enqueue(30);

Assuming the queue prints elements from head to tail.

medium

A. 10 -> 20 -> 30 -> null

B. 30 -> 20 -> 10 -> null

C. null -> 10 -> 20 -> 30

D. 20 -> 30 -> 10 -> null

Solution

1. Step 1: Enqueue 10, 20, 30 in order

   Each enqueue adds element at the tail, so order is 10, then 20, then 30.

2. Step 2: Print queue from head to tail

   Head points to 10, followed by 20, then 30, ending with null.

3. Final Answer:

   10 -> 20 -> 30 -> null -> Option A

4. Quick Check:

   Enqueue order preserved from head to tail [OK]

Hint: Enqueue adds at tail, print from head to tail [OK]

Common Mistakes:

• Reversing the order of elements
• Confusing head and tail pointers
• Assuming enqueue adds at head

4. Identify the error in the following enqueue method for a linked list queue in C#:

public void Enqueue(int data) {
    Node newNode = new Node(data);
    if (head == null) {
        head = newNode;
    } else {
        tail.next = newNode;
    }
}

medium

A. New node should be created outside the method

B. The tail pointer is not updated after adding new node

C. The head pointer should be updated instead of tail

D. The if condition should check tail instead of head

Solution

1. Step 1: Check tail update after enqueue

   After adding newNode at tail.next, tail must be updated to newNode.

2. Step 2: Identify missing tail update

   Code does not update tail, so tail still points to old last node, causing errors.

3. Final Answer:

   The tail pointer is not updated after adding new node -> Option B

4. Quick Check:

   Always update tail after enqueue [OK]

Hint: Update tail pointer after adding new node [OK]

Common Mistakes:

• Forgetting to update tail pointer
• Updating head instead of tail
• Creating node outside enqueue method

5. Given a linked list queue with elements 5 -> 15 -> 25 -> null, what will be the queue state after enqueueing 35 and then dequeueing one element?

hard

A. 25 -> 35 -> null

B. 5 -> 15 -> 25 -> 35 -> null

C. 15 -> 25 -> 35 -> null

D. 35 -> 5 -> 15 -> 25 -> null

Solution

1. Step 1: Enqueue 35 at tail

   Queue becomes 5 -> 15 -> 25 -> 35 -> null after enqueue.

2. Step 2: Dequeue removes from head

   Removing 5 from head leaves 15 -> 25 -> 35 -> null.

3. Final Answer:

   15 -> 25 -> 35 -> null -> Option C

4. Quick Check:

   Enqueue adds tail, dequeue removes head [OK]

Hint: Enqueue tail, dequeue head to update queue [OK]

Common Mistakes:

• Removing from tail instead of head
• Not updating head after dequeue
• Adding new element at head instead of tail