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

Reverse a Singly Linked List Iterative

📖 Scenario: You are working on a simple program that manages a list of tasks. Each task is linked to the next one, forming a chain. Sometimes, you want to see the tasks in reverse order.

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

📋 What You'll Learn

Create a singly linked list with exactly three nodes containing the values 10, 20, and 30 in that order.

Add a helper variable called prev initialized to null to assist in reversing the list.

Write an iterative loop that reverses the singly linked list by changing the links between nodes.

Print the reversed linked list in the format: 30 -> 20 -> 10 -> null

💡 Why This Matters

🌍 Real World

Reversing linked lists is useful in many applications like undo operations in software, reversing navigation paths, or processing data in reverse order.

💼 Career

Understanding linked list reversal is a common interview question and helps build strong problem-solving skills in data structure manipulation.

1

Create the singly linked list

Create a class called Node with an integer data and a Node reference called next. Then create three Node objects named head, second, and third with data values 10, 20, and 30 respectively. Link them so that head.next points to second and second.next points to third. Set third.next to null.

DSA Java

// Define Node class and create linked list nodes
// Your code here

Hint

Start by defining the Node class with data and next. Then create three nodes and link them in order.

2

Add a helper variable for reversal

Inside the main method, create a Node variable called prev and set it to null. This will help keep track of the previous node while reversing.

DSA Java

class Node {
    int data;
    Node next;
    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

public class Main {
    public static void main(String[] args) {
        Node head = new Node(10);
        Node second = new Node(20);
        Node third = new Node(30);
        head.next = second;
        second.next = third;
        third.next = null;
        // Create prev variable
        // Your code here
    }
}

Hint

Declare prev as a Node and assign it null.

3

Reverse the linked list iteratively

Write a while loop that runs while head is not null. Inside the loop, create a Node variable called nextNode to store head.next. Then set head.next to prev. Update prev to head and head to nextNode. After the loop ends, set head to prev.

DSA Java

class Node {
    int data;
    Node next;
    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

public class Main {
    public static void main(String[] args) {
        Node head = new Node(10);
        Node second = new Node(20);
        Node third = new Node(30);
        head.next = second;
        second.next = third;
        third.next = null;
        Node prev = null;
        // Write while loop to reverse linked list
        // Your code here
    }
}

Hint

Use a while loop to reverse the links one by one until head becomes null. Update prev and head inside the loop.

4

Print the reversed linked list

Use a Node variable called current and set it to head. Use a while loop to traverse the list while current is not null. Inside the loop, print current.data followed by " -> ". Move current to current.next. After the loop, print "null".

DSA Java

class Node {
    int data;
    Node next;
    Node(int data) {
        this.data = data;
        this.next = null;
    }
}

public class Main {
    public static void main(String[] args) {
        Node head = new Node(10);
        Node second = new Node(20);
        Node third = new Node(30);
        head.next = second;
        second.next = third;
        third.next = null;
        Node prev = null;
        while (head != null) {
            Node nextNode = head.next;
            head.next = prev;
            prev = head;
            head = nextNode;
        }
        head = prev;
        // Use current to print list
        // Your code here
    }
}

Hint

Use a while loop to print each node's data followed by " -> ". After the loop, print "null" to show the end of the list.

Practice

1. What is the main purpose of reversing a singly linked list iteratively?

easy

A. To sort the list in ascending order

B. To delete all nodes from the list

C. To change the direction of all links so the last node becomes the first

D. To add a new node 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 from head to tail.

2. Step 2: Purpose of reversing

   Reversing changes the links so the last node points to the previous one, making it the new head.

3. Final Answer:

   To change the direction of all links so the last node becomes the first -> Option C

4. Quick Check:

   Reversing = changing link directions [OK]

Hint: Reversing flips the list direction, last becomes first [OK]

Common Mistakes:

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

2. Which of the following is the correct way to initialize the previous pointer before starting the iterative reversal?

easy

A. Node prev = head;

B. Node prev = head.next;

C. Node prev = new Node();

D. Node prev = null;

Solution

1. Step 1: Understand the role of previous pointer

   Previous pointer starts as null because the new tail's next should be null after reversal.

2. Step 2: Initialization

   Setting prev to null ensures the first node processed points to null, ending the reversed list properly.

3. Final Answer:

   Node prev = null; -> Option D

4. Quick Check:

   Prev starts null to mark new tail [OK]

Hint: Prev pointer starts null to mark list end [OK]

Common Mistakes:

• Initializing prev to head causes cycle
• Creating new node wastes memory
• Starting prev at head.next skips first node

3. What will be the output linked list after reversing the list 1 -> 2 -> 3 -> null iteratively?

medium

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

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

C. null -> 3 -> 2 -> 1

D. 2 -> 3 -> 1 -> null

Solution

1. Step 1: Trace the reversal process

   Initially: 1 -> 2 -> 3 -> null. After reversal, links point backward: 3 -> 2 -> 1 -> null.

2. Step 2: Confirm final head and tail

   Node 3 becomes new head, node 1 becomes tail pointing to null.

3. Final Answer:

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

4. Quick Check:

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

Hint: Last node becomes first after reversal [OK]

Common Mistakes:

• Assuming list stays same after reversal
• Confusing null placement
• Mixing node order

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

Node prev = head;
Node current = head.next;
while (current != null) {
  Node nextNode = current.next;
  current.next = prev;
  prev = current;
  current = nextNode;
}
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. Loop condition should be current.next != null

Solution

1. Step 1: Check initialization of prev pointer

   Prev must start as null to mark new tail's next as null after reversal.

2. Step 2: Effect of wrong initialization

   Starting prev at head causes a cycle, breaking reversal logic.

3. Final Answer:

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

4. Quick Check:

   Prev = null to avoid cycles [OK]

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

Common Mistakes:

• Starting prev at head causes infinite loop
• Wrong loop condition misses last node
• Forgetting to set old head next to null

5. Given a singly linked list with nodes containing values 10 -> 20 -> 30 -> 40 -> null, which iterative code snippet correctly reverses it and prints the reversed list?

hard

A. Node prev = null;
Node current = head;
while (current != null) {
Node next = current.next;
current.next = prev;
prev = current;
current = next;
}
head = prev;
// Print list starting from head

B. Node prev = head;
Node current = head.next;
while (current != null) {
Node next = current.next;
current.next = prev;
prev = current;
current = next;
}
head = prev;
// Print list starting from head

C. Node current = head;
while (current != null) {
Node next = current.next;
current.next = null;
current = next;
}
// Print list starting from head

D. Node prev = null;
Node current = head;
while (current.next != null) {
Node next = current.next;
current.next = prev;
prev = current;
current = next;
}
head = prev;
// Print list starting from head

Solution

1. Step 1: Verify initialization of pointers

   Prev must start as null, current at head to reverse all nodes correctly.

2. Step 2: Check loop condition and pointer updates

   Loop runs while current != null to process all nodes; inside loop, links reversed properly.

3. Step 3: Confirm final head assignment and printing

   After loop, head is set to prev (new head). Printing from head shows reversed list.

4. Final Answer:

   Option A code correctly reverses and prints the list -> Option A

5. Quick Check:

   Prev=null, loop full list, head=prev [OK]

Hint: Prev null, loop full list, head = prev after reversal [OK]

Common Mistakes:

• Starting prev at head causes cycle
• Loop condition misses last node
• Setting current.next = null inside loop breaks links