Reverse a Sub-list (Reverse Nodes Between Positions p and q)

Walk to the node just before position p, reverse exactly q-p+1 nodes using the three-pointer technique, then re-stitch the reversed segment back to the node before p and to the node after q. The untouched prefix and suffix keep their links.

What is the problem?

Reverse a Sub-list (Reverse Nodes Between Positions p and q). Given the head of a singly linked list and two positions p and q (1-based, p <= q), reverse the nodes from position p to position q in place and return the head. Do it in a single pass with O(1) extra space.

How does the approach work?

Use a dummy node before the head so that reversing from position 1 needs no special case. Advance a pointer beforeP by p-1 steps so it sits just before the segment. Let segStart be beforeP.next, the first node of the segment, which will become the segment's tail after reversal. Then reverse q-p+1 nodes with the standard three-pointer loop. Finally re-stitch: beforeP.next points to the new segment head (previous), and segStart.next points to the node that follows the segment (current).

For example reversing positions 2 to 4 of 1 -> 2 -> 3 -> 4 -> 5 gives 1 -> 4 -> 3 -> 2 -> 5. The dummy makes the p=1 case fall out naturally because beforeP is the dummy.

A senior-level nuance is the re-stitching order and the role of segStart: because segStart is the original first node of the run, after reversal it is the run's last node, so its next is exactly where the suffix must attach. Getting these two reconnections right is the entire difficulty; the reversal itself is the easy part you already know from full-list reversal.

What is the banking use case?

The code contains a SlipNode, a DisputeView with reverseBetween(head, p, q), and a demo.

How do you implement this in Java?

// ─── File: src/main/java/com/bank/dispute/SlipNode.java ───
package com.bank.dispute;

public class SlipNode {
    final int id;
    SlipNode next;
    SlipNode(int id) { this.id = id; }
}

// ─── File: src/main/java/com/bank/dispute/DisputeView.java ───
package com.bank.dispute;

public class DisputeView {

    public SlipNode reverseBetween(SlipNode head, int p, int q) {
        if (head == null || p == q) return head;
        SlipNode dummy = new SlipNode(-1);
        dummy.next = head;

        SlipNode beforeP = dummy;
        for (int i = 0; i < p - 1; i++) beforeP = beforeP.next;  // node before position p

        SlipNode segStart = beforeP.next;   // becomes the segment TAIL after reversal
        SlipNode previous = null, current = segStart;
        for (int i = 0; i < q - p + 1; i++) {   // reverse exactly q-p+1 nodes
            SlipNode next = current.next;
            current.next = previous;
            previous = current;
            current = next;
        }
        beforeP.next = previous;      // prefix → new segment head
        segStart.next = current;      // segment tail → suffix
        return dummy.next;
    }
}

// ─── File: src/main/java/com/bank/dispute/SublistDemo.java ───
package com.bank.dispute;

import java.util.logging.Logger;

public class SublistDemo {
    private static final Logger log = Logger.getLogger(SublistDemo.class.getName());

    public static void main(String[] args) {
        SlipNode head = build(new int[]{1, 2, 3, 4, 5});
        log.info("Original: " + render(head));

        SlipNode out = new DisputeView().reverseBetween(head, 2, 4);
        log.info("Reversed positions 2..4: " + render(out));
    }

    static SlipNode build(int[] ids) {
        SlipNode d = new SlipNode(-1), t = d;
        for (int id : ids) { t.next = new SlipNode(id); t = t.next; }
        return d.next;
    }

    static String render(SlipNode n) {
        StringBuilder sb = new StringBuilder();
            while (n != null) { sb.append(n.id);
            if (n.next != null) sb.append(" -> "); n = n.next; }
        return sb.append(" -> null").toString();
    }
}

What is the project structure?

dispute-sublist-reverser/
├── pom.xml
└── src/main/java/com/bank/dispute/
    ├── SublistDemo.java
    ├── SlipNode.java
    └── DisputeView.java

How do you build and run?

# Build
mvn clean package -DskipTests
# Run
java -cp target/classes com.bank.dispute.SublistDemo

What is the step-by-step walkthrough?

Input data: chain 1 -> 2 -> 3 -> 4 -> 5, p=2, q=4.

Final output:

2026-10-27 19:25:42 [INFO] Original: 1 -> 2 -> 3 -> 4 -> 5 -> null
2026-10-27 19:25:42 [INFO] Reversed positions 2..4: 1 -> 4 -> 3 -> 2 -> 5 -> null

What is the high-level design?

  ═══ HLD — Dispute Window Reversal ═══

  ┌──────────┐ window ┌────────────────────┐ nodes ┌──────────────┐
  │ Agent UI │───────→│ Dispute Svc ×2     │──────→│ slip chain   │
  └──────────┘        │ reverseBetween(p,q)│       │ (in memory)  │
                      └────────────────────┘       └──────────────┘

What is the low-level design?

  ═══ LLD — DisputeView ═══

  ┌─ Key references ────────────────────────────────────┐
  │  dummy → handles p=1 uniformly                      │
  │  segStart → original head of run = tail after rev   │
  └──────────────────────────────────────────────────────┘

  ┌──────────────────────────────────────────┐
  │               DisputeView                 │
  │  + reverseBetween(head,p,q): SlipNode     │  single pass, O(1)
  └──────────────────────────────────────────┘

  Contract for reverseBetween(head,p,q):
    Pre:  1 ≤ p ≤ q ≤ length
    Post: nodes [p..q] reversed; prefix/suffix intact

What is the time and space complexity?

Analyze the solution based on the algorithm used. Consider both the time to process input and the space required for any data structures.

What are common mistakes?

Common mistakes include off-by-one errors, not handling edge cases like empty input, and not considering the constraints of the problem.

What are the edge cases?

Edge cases include empty input, single element input, all identical elements, and boundary values.

What should a senior engineer know?

A senior engineer should understand the time-space tradeoffs, be able to explain the algorithm clearly, and know when this technique applies versus alternatives.