Linked List In-Place Reversal is a technique that reverses the direction of pointers in a linked list to change the order of nodes. Instead of creating a new reversed list or using extra storage, we modify the existing next pointers so that each node points to its predecessor rather than its successor.

The core operation involves three pointers working together:

prev: Points to the previously processed node (starts as null)
curr: Points to the current node being processed
next: Temporarily stores the next node before we modify curr.next

The beauty of this approach is that we are not moving data around or allocating new nodes. We are simply rewiring the connections between existing nodes. Each node stays in its memory location; only the pointers change.

Why Does This Technique Work?

The in-place reversal technique works because linked list nodes are independent objects connected only by pointers. Unlike arrays where elements must be contiguous in memory, linked list nodes can exist anywhere in memory and rely solely on their next pointer to define the sequence.

When we reverse a linked list in-place:

No data movement: The values stored in each node remain untouched. We only modify the next pointers.
Constant extra space: We need only a fixed number of pointer variables (typically 3), regardless of the list length. This gives us O(1) space complexity.
Single pass efficiency: By processing each node exactly once and updating its pointer, we achieve O(n) time complexity.

The key insight is that each node's next pointer is independent. When we change node A's next to point to something else, it does not affect what node B's next points to. This independence allows us to systematically redirect all pointers in a single pass through the list.

When to Use This Pattern

The in-place reversal pattern is your go-to technique when you encounter these situations:

1. Reversing a linked list (full or partial)

Whenever a problem asks you to reverse all or part of a linked list, this is the primary technique. Whether it is the entire list or just a section between two positions, the same pointer manipulation applies.

2. Checking for palindromes

To check if a linked list is a palindrome, you can reverse the second half and compare it with the first half. This combines the fast-slow pointer technique (to find the middle) with in-place reversal.

3. Reordering nodes

Problems that ask you to reorder nodes in a specific pattern often require reversing parts of the list. For example, alternating nodes from the start and end of a list.

4. K-group operations

When you need to process nodes in groups (like reversing every k nodes), in-place reversal applied to each group is the core operation.

Here are the telltale signs that a problem might need in-place reversal:

Indicator	Examples
"Reverse" in problem statement	Reverse Linked List, Reverse Between
Checking palindrome	Palindrome Linked List
Reorder or interleave	Reorder List, Odd Even Linked List
K-group processing	Reverse Nodes in k-Group, Swap Nodes in Pairs
Comparing first and second half	Palindrome checks, fold matching

Pattern Variants

The in-place reversal technique manifests in several forms, each building on the basic idea but adding complexity:

Variant 1: Full List Reversal

The simplest case. Reverse the entire linked list from head to tail. The original head becomes the tail, and the original tail becomes the new head.

Variant 2: Partial Reversal (Between Positions)

Reverse only a portion of the list, from position m to position n. Nodes before m and after n remain in their original order. This requires careful handling of the connection points.

Variant 3: K-Group Reversal

Reverse nodes in groups of k. If the remaining nodes are fewer than k, they may be left as-is or reversed depending on the problem variant.

Variant 4: Alternating Reversal

Reverse alternate groups. For example, reverse the first k nodes, keep the next k as-is, reverse the next k, and so on.

Each variant requires understanding the basic reversal mechanism and then adapting it to handle boundaries and connections appropriately.

The Reversal Templates

Most in-place reversal problems use one of two fundamental approaches. Let us establish them clearly.

Template 1: Iterative Reversal (Three-Pointer Technique)

This is the workhorse of linked list reversal. Three pointers work in coordination to reverse the list in a single pass.

The four operations inside the loop (in order):

Save: Store curr.next before we overwrite it
Reverse: Point curr.next backward to prev
Advance prev: Move prev to curr
Advance curr: Move curr to the saved next

The order of these operations is critical. Changing the order will break the algorithm.

Template 2: Recursive Reversal

The recursive approach is elegant but uses O(n) stack space. It works by recursing to the end of the list, then rewiring pointers on the way back.

How the recursion works:

Recurse until you reach the last node (base case)
The last node becomes the new head
On the way back, each node makes its next node point to itself
Each node sets its own next to null to prevent cycles

The recursive approach is less intuitive but demonstrates a beautiful property of recursion: solving the smaller problem first, then handling the connection.

When to Use Which

Approach	Pros	Cons	Best For
Iterative	O(1) space, straightforward	More code	Production code, interviews
Recursive	Elegant, less code	O(n) stack space	Understanding concepts, small lists

In interviews, the iterative approach is generally preferred because it uses constant space. However, being able to explain both shows deeper understanding.

Introduction to Linked List In-Place Reversal

Ashish Pratap Singh