Reverse a Singly Linked List Iterative in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of reversing a 3-node linked list

What is the printed state of the linked list after reversing it iteratively?

DSA Go

package main

import "fmt"

type Node struct {
    value int
    next  *Node
}

func reverseList(head *Node) *Node {
    var prev *Node = nil
    current := head
    for current != nil {
        nextTemp := current.next
        current.next = prev
        prev = current
        current = nextTemp
    }
    return prev
}

func printList(head *Node) {
    for head != nil {
        fmt.Printf("%d -> ", head.value)
        head = head.next
    }
    fmt.Println("null")
}

func main() {
    head := &Node{value: 1}
    head.next = &Node{value: 2}
    head.next.next = &Node{value: 3}

    reversed := reverseList(head)
    printList(reversed)
}

A 3 -> 2 -> 1 -> null

B 1 -> 2 -> 3 -> null

C null

D 1 -> null

💡 Hint

Think about how the pointers change direction in the iterative reversal.

The iterative reversal changes the next pointers of each node to point to the previous node, reversing the list order from 1->2->3 to 3->2->1.

❓ Predict Output

intermediate

Output when reversing an empty linked list

What is the printed state of the linked list after reversing an empty list iteratively?

DSA Go

package main

import "fmt"

type Node struct {
    value int
    next  *Node
}

func reverseList(head *Node) *Node {
    var prev *Node = nil
    current := head
    for current != nil {
        nextTemp := current.next
        current.next = prev
        prev = current
        current = nextTemp
    }
    return prev
}

func printList(head *Node) {
    for head != nil {
        fmt.Printf("%d -> ", head.value)
        head = head.next
    }
    fmt.Println("null")
}

func main() {
    var head *Node = nil

    reversed := reverseList(head)
    printList(reversed)
}

A empty list error

B null

C 0 -> null

D nil pointer exception

💡 Hint

Consider what happens when the input list is nil.

Reversing an empty list returns nil, so printing it results in just 'null'.

🔧 Debug

advanced

Identify the bug in this iterative reversal code

What error will this code cause when reversing a linked list iteratively?

DSA Go

func reverseList(head *Node) *Node {
    var prev *Node = nil
    current := head
    for current.next != nil {
        nextTemp := current.next
        current.next = prev
        prev = current
        current = nextTemp
    }
    return prev
}

A Runtime error: nil pointer dereference

B Compilation error

C Correct reversal output

D Infinite loop

💡 Hint

Check the loop condition and what happens when current is the last node.

The loop condition 'current.next != nil' skips processing the last node, so when current becomes nil, accessing current.next causes a nil pointer dereference.

❓ Predict Output

advanced

Output after reversing a single-node linked list

What is the printed state of the linked list after reversing a single-node list iteratively?

DSA Go

package main

import "fmt"

type Node struct {
    value int
    next  *Node
}

func reverseList(head *Node) *Node {
    var prev *Node = nil
    current := head
    for current != nil {
        nextTemp := current.next
        current.next = prev
        prev = current
        current = nextTemp
    }
    return prev
}

func printList(head *Node) {
    for head != nil {
        fmt.Printf("%d -> ", head.value)
        head = head.next
    }
    fmt.Println("null")
}

func main() {
    head := &Node{value: 42}

    reversed := reverseList(head)
    printList(reversed)
}

A Runtime error

B null

C 42 -> 42 -> null

D 42 -> null

💡 Hint

Reversing a single node list should not change the list.

A single node reversed still points to nil, so the list remains '42 -> null'.

🧠 Conceptual

expert

Why does iterative reversal use three pointers?

In iterative reversal of a singly linked list, why do we need to keep track of three pointers: prev, current, and nextTemp?

A To create a new list instead of reversing in place

B To sort the list while reversing

C To reverse the links safely without losing access to the rest of the list

D To count the number of nodes during reversal

💡 Hint

Think about what happens if you change a link without saving the next node.

We use prev to point to the reversed part, current to the node being processed, and nextTemp to save the next node before changing links. This prevents losing access to the rest of the list.

Practice

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

easy

A. To sort the linked list in ascending order

B. To create a new linked list with reversed elements

C. To delete all nodes and recreate them in reverse order

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

Solution

1. Step 1: Understand the linked list structure

   A singly linked list has nodes pointing to the next node only, so reversing means changing these pointers.

2. Step 2: Purpose of iterative reversal

   The iterative method changes the next pointer of each node to point to the previous node, reversing the list in place.

3. Final Answer:

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

4. Quick Check:

   Reversing means changing links direction [OK]

Hint: Reversing means flipping links, not creating new nodes [OK]

Common Mistakes:

• Thinking it creates a new list instead of reversing in place
• Confusing reversal with sorting
• Assuming nodes are deleted and recreated

2. Which of the following Go code snippets correctly initializes pointers for iterative reversal of a singly linked list?

easy

A. var prev = head; current := nil

B. var prev *Node = nil; current := head

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

D. var prev *Node = head; current := head

Solution

1. Step 1: Initialization for reversal

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

2. Step 2: Check each option

   var prev *Node = nil; current := head correctly sets prev to nil and current to head. Others incorrectly assign prev or current.

3. Final Answer:

   var prev *Node = nil; current := head -> Option B

4. Quick Check:

   Prev starts nil, current at head [OK]

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

Common Mistakes:

• Setting prev to head initially
• Setting current to nil at start
• Mixing pointer assignments

3. What will be the output linked list after running this Go code to reverse a singly linked list?

type Node struct {
    Val  int
    Next *Node
}

func reverseList(head *Node) *Node {
    var prev *Node = nil
    current := head
    for current != nil {
        nextTemp := current.Next
        current.Next = prev
        prev = current
        current = nextTemp
    }
    return prev
}

// Input list: 1 -> 2 -> 3 -> nil
// Call: reverseList(head)

medium

A. 3 -> 2 -> 1 -> nil

B. 1 -> 2 -> 3 -> nil

C. nil -> 3 -> 2 -> 1

D. 3 -> 1 -> 2 -> nil

Solution

1. Step 1: Trace the reversal loop

   Initially prev=nil, current=1. Each iteration reverses current.Next to prev and moves pointers forward.

2. Step 2: Final reversed list

   After loop, prev points to node with Val=3, linked as 3->2->1->nil.

3. Final Answer:

   3 -> 2 -> 1 -> nil -> Option A

4. Quick Check:

   Reversed list order is 3,2,1 [OK]

Hint: Follow pointer changes step-by-step [OK]

Common Mistakes:

• Confusing original and reversed order
• Misunderstanding pointer updates
• Assuming list remains unchanged

4. Identify the error in this Go code snippet for reversing a singly linked list iteratively:

func reverseList(head *Node) *Node {
    var prev *Node = head
    current := head
    for current != nil {
        nextTemp := current.Next
        current.Next = prev
        prev = current
        current = nextTemp
    }
    return prev
}

medium

A. prev should be initialized to nil, not head

B. current should be initialized to nil

C. nextTemp should be initialized outside the loop

D. The function should return current, not prev

Solution

1. Step 1: Check initialization of prev

   Prev must start as nil because the new tail's next is nil. Setting prev=head causes a cycle.

2. Step 2: Effect of wrong prev initialization

   Setting prev=head makes current.Next point to itself on first iteration, causing infinite loop or wrong reversal.

3. Final Answer:

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

4. Quick Check:

   Prev starts nil to avoid cycles [OK]

Hint: Prev must start nil to break old links [OK]

Common Mistakes:

• Initializing prev to head causing cycles
• Returning current instead of prev
• Misplacing nextTemp initialization

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

hard

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

B. nil

C. 10 -> 20 -> 30 -> 40 -> nil

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

Solution

1. Step 1: First reversal

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

2. Step 2: Second reversal

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

3. Final Answer:

   10 -> 20 -> 30 -> 40 -> nil -> Option C

4. Quick Check:

   Double reversal returns original list [OK]

Hint: Reversing twice returns original list [OK]

Common Mistakes:

• Assuming second reversal changes order differently
• Confusing node values after reversal
• Thinking list becomes empty