Reverse a Singly Linked List Iterative in DSA C# - Build from Scratch

Reverse a Singly Linked List Iterative

📖 Scenario: You are working on a simple program that manages a list of numbers. The numbers are stored in a singly linked list, where each number points to the next one. You want to reverse the order of the numbers in the list so that the last number becomes the first, and the first becomes the last.

🎯 Goal: Build a program that creates a singly linked list with specific numbers, then reverses the list using an iterative method, and finally prints the reversed list.

📋 What You'll Learn

Create a singly linked list with nodes containing the values 1, 2, 3, 4, and 5 in that order.

Add a variable to help with the reversal process.

Write an iterative method to reverse the singly linked list.

Print the reversed linked list showing the node values in order.

💡 Why This Matters

🌍 Real World

Reversing linked lists is useful in many applications like undo features, navigation history, and data processing pipelines.

💼 Career

Understanding linked list reversal is a common interview question and helps build strong problem-solving skills in software development.

1

Create the singly linked list

Create a class called Node with an int field called Value and a Node field called Next. Then create a linked list with nodes containing the values 1, 2, 3, 4, and 5 in that order. Store the first node in a variable called head.

DSA C#

// Define the Node class and create the linked list with head node
// Your code here

Hint

Start by defining the Node class with Value and Next fields. Then link the nodes one by one to form the list.

2

Add helper variables for reversal

Add two variables called previous and current. Set previous to null and current to head. These will help you reverse the list.

DSA C#

public class Node
{
    public int Value;
    public Node Next;

    public Node(int value)
    {
        Value = value;
        Next = null;
    }
}

Node head = new Node(1);
head.Next = new Node(2);
head.Next.Next = new Node(3);
head.Next.Next.Next = new Node(4);
head.Next.Next.Next.Next = new Node(5);

// Add variables previous and current for reversal
// Your code here

Hint

Set previous to null because the reversed list will end with null. Set current to head to start from the first node.

3

Write the iterative reversal logic

Write a while loop that runs while current is not null. Inside the loop, create a variable nextNode to store current.Next. Then set current.Next to previous. Move previous to current and current to nextNode. After the loop, set head to previous.

DSA C#

public class Node
{
    public int Value;
    public Node Next;

    public Node(int value)
    {
        Value = value;
        Next = null;
    }
}

Node head = new Node(1);
head.Next = new Node(2);
head.Next.Next = new Node(3);
head.Next.Next.Next = new Node(4);
head.Next.Next.Next.Next = new Node(5);

Node previous = null;
Node current = head;

// Write the iterative reversal loop below
// Your code here

Hint

Use the while loop to go through each node. Change the Next pointer to point backwards. Update previous and current to move forward.

4

Print the reversed linked list

Use a Node variable called temp starting at head. Use a while loop to print each node's Value followed by " -> " until temp is null. After the loop, print "null".

DSA C#

public class Node
{
    public int Value;
    public Node Next;

    public Node(int value)
    {
        Value = value;
        Next = null;
    }
}

Node head = new Node(1);
head.Next = new Node(2);
head.Next.Next = new Node(3);
head.Next.Next.Next = new Node(4);
head.Next.Next.Next.Next = new Node(5);

Node previous = null;
Node current = head;

while (current != null)
{
    Node nextNode = current.Next;
    current.Next = previous;
    previous = current;
    current = nextNode;
}

head = previous;

// Print the reversed linked list
// Your code here

Hint

Use a temporary variable to walk through the reversed list and print each value followed by an arrow. End with "null" to show the list end.

Practice

1. What is the main purpose of the iterative method to reverse a singly linked list?

easy

A. To sort the nodes in ascending order

B. To delete all nodes from the list

C. To change the direction of the links between nodes one by one

D. To add new nodes at the end of the list

Solution

1. Step 1: Understand the linked list structure

   A singly linked list has nodes connected in one direction through next pointers.

2. Step 2: Purpose of iterative reversal

   The iterative method changes each node's next pointer to point backward, reversing the list.

3. Final Answer:

   To change the direction of the links between nodes one by one -> Option C

4. Quick Check:

   Reversing = changing links direction [OK]

Hint: Reversing means flipping the links one by one [OK]

Common Mistakes:

• Thinking reversal deletes nodes
• Confusing reversal with sorting
• Assuming reversal adds nodes

2. Which of the following is the correct way to initialize pointers for iterative reversal of a singly linked list in C#?

easy

A. Node prev = head; Node current = null;

B. Node prev = null; Node current = null;

C. Node prev = head; Node current = head.next;

D. Node prev = null; Node current = head;

Solution

1. Step 1: Initialization for reversal

   We start with prev as null because the new tail will point to null, and current at head to traverse.

2. Step 2: Check each option

   Only Node prev = null; Node current = head; correctly sets prev to null and current to head for iteration.

3. Final Answer:

   Node prev = null; Node current = head; -> Option D

4. Quick Check:

   Start prev=null, current=head [OK]

Hint: Prev starts null, current starts at head [OK]

Common Mistakes:

• Setting prev to head initially
• Setting current to null
• Both pointers null at start

3. What will be the output linked list after running this code snippet on list 1 -> 2 -> 3 -> null?

Node prev = null;
Node current = head;
while (current != null) {
  Node nextTemp = current.next;
  current.next = prev;
  prev = current;
  current = nextTemp;
}
head = prev;

medium

A. 1 -> 2 -> 3 -> null

B. 3 -> 2 -> 1 -> null

C. null

D. 1 -> null

Solution

1. Step 1: Trace the reversal loop

   Each iteration reverses the link: 1 points to null, 2 points to 1, 3 points to 2.

2. Step 2: Final linked list after loop

   After loop, prev points to 3, which is new head: 3 -> 2 -> 1 -> null.

3. Final Answer:

   3 -> 2 -> 1 -> null -> Option B

4. Quick Check:

   Reversed list = 3->2->1 [OK]

Hint: Reversal flips list order completely [OK]

Common Mistakes:

• Assuming list stays same
• Forgetting to update head
• Confusing next and prev pointers

4. Identify the error in this iterative reversal code snippet:

Node prev = head;
Node current = head.next;
while (current != null) {
  Node nextTemp = current.next;
  current.next = prev;
  prev = current;
  current = nextTemp;
}
head.next = null;
head = prev;

medium

A. prev should be initialized to null, not head

B. current should start at head, not head.next

C. head.next should not be set to null

D. No error, code is correct

Solution

1. Step 1: Check pointer initialization

   prev must start as null to mark new tail's next as null; starting at head causes cycle.

2. Step 2: Effect of wrong initialization

   Starting prev at head causes the first node to point to itself, creating a loop.

3. Final Answer:

   prev should be initialized to null, not head -> Option A

4. Quick Check:

   Prev must be null at start [OK]

Hint: Prev must start null to avoid cycles [OK]

Common Mistakes:

• Starting prev at head causing loops
• Not setting head.next to null after reversal
• Starting current at wrong node

5. Given a singly linked list with nodes containing values 10 -> 20 -> 30 -> 40 -> null, write the final linked list after applying iterative reversal twice in a row.

hard

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

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

C. null

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

Solution

1. Step 1: First reversal

   Reversing 10->20->30->40 gives 40->30->20->10->null.

2. Step 2: Second reversal

   Reversing again restores original order: 10->20->30->40->null.

3. Final Answer:

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

4. Quick Check:

   Double reversal restores original list [OK]

Hint: Reversing twice returns original list [OK]

Common Mistakes:

• Assuming second reversal changes order again
• Confusing node values after reversal
• Forgetting reversal is reversible