Enqueue Using Linked List in DSA C# - Build from Scratch

Enqueue Using Linked List

📖 Scenario: You are building a simple queue system for a ticket counter. People join the queue one by one, and you want to keep track of them in the order they arrive.

🎯 Goal: Create a linked list to represent the queue and add new people to the end of the queue using the enqueue operation.

📋 What You'll Learn

Create a Node class with data and next fields

Create a Queue class with front and rear nodes

Implement an Enqueue method to add a new node at the end

Print the queue after adding new people

💡 Why This Matters

🌍 Real World

Queues are used in real life to manage lines of people waiting for service, like at banks, ticket counters, or call centers.

💼 Career

Understanding how to implement queues with linked lists is important for software developers working on systems that require ordered processing, such as task scheduling or messaging.

1

Create Node and Queue classes

Create a Node class with a public string field data and a public Node field next. Then create a Queue class with public Node fields front and rear, both initialized to null.

DSA C#

// Define Node class
// Define Queue class with front and rear nodes

Hint

Start by defining the Node class with data and next. Then define the Queue class with front and rear nodes set to null.

2

Add Enqueue method to Queue

Inside the Queue class, add a public method Enqueue that takes a string parameter value. Create a new Node with value. If rear is null, set both front and rear to the new node. Otherwise, set rear.next to the new node and update rear to the new node.

DSA C#

public class Node
{
    public string data;
    public Node next;

    public Node(string data)
    {
        this.data = data;
        this.next = null;
    }
}

public class Queue
{
    public Node front = null;
    public Node rear = null;

    // Add Enqueue method here
}

Hint

Check if the queue is empty by seeing if rear is null. If empty, set both front and rear to the new node. Otherwise, link the new node after rear and update rear.

3

Add method to print the queue

Inside the Queue class, add a public method PrintQueue that prints all node data values from front to rear separated by -> . Use a Node variable current to traverse from front until null.

DSA C#

public class Node
{
    public string data;
    public Node next;

    public Node(string data)
    {
        this.data = data;
        this.next = null;
    }
}

public class Queue
{
    public Node front = null;
    public Node rear = null;

    public void Enqueue(string value)
    {
        Node newNode = new Node(value);
        if (rear == null)
        {
            front = newNode;
            rear = newNode;
        }
        else
        {
            rear.next = newNode;
            rear = newNode;
        }
    }

    // Add PrintQueue method here
}

Hint

Use a while loop to move through the nodes starting at front. Print each data and add -> between nodes. End with -> null.

4

Enqueue people and print the queue

In the Main method, create a Queue object called ticketQueue. Enqueue these people in order: "Alice", "Bob", "Charlie". Then call ticketQueue.PrintQueue() to display the queue.

DSA C#

using System;

public class Node
{
    public string data;
    public Node next;

    public Node(string data)
    {
        this.data = data;
        this.next = null;
    }
}

public class Queue
{
    public Node front = null;
    public Node rear = null;

    public void Enqueue(string value)
    {
        Node newNode = new Node(value);
        if (rear == null)
        {
            front = newNode;
            rear = newNode;
        }
        else
        {
            rear.next = newNode;
            rear = newNode;
        }
    }

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

class Program
{
    static void Main()
    {
        // Enqueue Alice, Bob, Charlie and print queue
    }
}

Hint

Create a Queue object named ticketQueue. Use Enqueue to add "Alice", "Bob", and "Charlie" in that order. Then call PrintQueue to show the queue.

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