Reorder Linked List in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to find the middle node of the linked list using the slow and fast pointer technique.

DSA Java

ListNode slow = head;
ListNode fast = head;
while (fast != null && fast.next != null) {
    slow = slow.[1];
    fast = fast.next.next;
}

Drag options to blanks, or click blank then click option'

Ahead

Bprev

Cnext

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Using fast.next instead of slow.next for the slow pointer.

Using prev which is not defined in singly linked list.

The slow pointer moves one step at a time using slow.next to find the middle node.

2fill in blank

medium

Complete the code to reverse the second half of the linked list starting from the middle node.

DSA Java

ListNode prev = null;
ListNode curr = slow;
while (curr != null) {
    ListNode nextTemp = curr.[1];
    curr.next = prev;
    prev = curr;
    curr = nextTemp;
}

Drag options to blanks, or click blank then click option'

Anext

Bprev

Chead

Dcurr

Attempts:

3 left

💡 Hint

Common Mistakes

Using prev instead of next to get the next node.

Not storing the next node before reversing the link.

We store the next node using curr.next before reversing the link.

3fill in blank

hard

Fix the error in the merging step to reorder the list by alternating nodes from the first and reversed second half.

DSA Java

ListNode first = head;
ListNode second = prev;
while (second.next != null) {
    ListNode tmp1 = first.next;
    ListNode tmp2 = second.next;
    first.next = second;
    second.next = tmp1;
    first = tmp1;
    second = [1];
}

Drag options to blanks, or click blank then click option'

Atmp1

Bfirst

Csecond

Dtmp2

Attempts:

3 left

💡 Hint

Common Mistakes

Moving second to first or tmp1 which breaks the merge.

Not updating second pointer causing infinite loop.

After linking, move second pointer to tmp2 which is the next node in reversed half.

4fill in blank

hard

Fill both blanks to complete the method that reorders the linked list as per the problem statement.

DSA Java

public void reorderList(ListNode head) {
    if (head == null || head.next == null) return;
    ListNode slow = head, fast = head;
    while (fast != null && fast.next != null) {
        slow = slow.[1];
        fast = fast.next.next;
    }
    ListNode prev = null, curr = slow;
    while (curr != null) {
        ListNode nextTemp = curr.[2];
        curr.next = prev;
        prev = curr;
        curr = nextTemp;
    }
    ListNode first = head, second = prev;
    while (second.next != null) {
        ListNode tmp1 = first.next;
        ListNode tmp2 = second.next;
        first.next = second;
        second.next = tmp1;
        first = tmp1;
        second = tmp2;
    }
}

Drag options to blanks, or click blank then click option'

Anext

Bprev

Chead

Dcurr

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' or 'curr' instead of 'next' causing null pointer exceptions.

Mixing up pointer movements leading to incorrect list structure.

Both blanks require 'next' to traverse the list correctly.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension-like map of node values to their positions during reordering (simulate with Java Map).

DSA Java

Map<Integer, Integer> nodePositions = new HashMap<>();
int pos = 0;
ListNode current = head;
while (current != null) {
    nodePositions.put(current.[1], [2]);
    current = current.[3];
    pos++;
}

Drag options to blanks, or click blank then click option'

Aval

Bpos

Cnext

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'value' instead of 'val' which is not defined.

Using 'prev' or other invalid pointers.

Not incrementing position correctly.

Use 'val' for node value, 'pos' for position, and 'next' to move to next node.

Practice

1. What is the main goal of the Reorder Linked List problem?

easy

A. Sort the linked list in ascending order

B. Rearrange the list so nodes alternate from start and end towards the center

C. Reverse the entire linked list

D. Remove duplicate nodes from the linked list

Solution

1. Step 1: Understand the problem requirement

   The problem asks to reorder the list so that nodes come alternately from the start and end, like L0 -> Ln -> L1 -> Ln-1 -> L2 -> Ln-2 ...

2. Step 2: Differentiate from other operations

   This is not sorting or reversing the whole list, but a specific rearrangement pattern.

3. Final Answer:

   Rearrange the list so nodes alternate from start and end towards the center -> Option B

4. Quick Check:

   Reorder = alternate start/end nodes [OK]

Hint: Think of weaving nodes from front and back alternately [OK]

Common Mistakes:

• Confusing reorder with sorting
• Trying to reverse the whole list only
• Ignoring the alternating pattern

2. Which Java code snippet correctly splits a linked list into two halves using slow and fast pointers?

easy

A. ListNode slow = head, fast = head; while(fast.next != null) { slow = slow.next; fast = fast.next; }

B. ListNode slow = head.next, fast = head; while(fast != null) { slow = slow.next; fast = fast.next.next; }

C. ListNode slow = head, fast = head; while(fast != null && fast.next != null) { slow = slow.next; fast = fast.next.next; }

D. ListNode slow = head, fast = head.next; while(fast != null && fast.next != null) { slow = slow.next; fast = fast.next.next; }

Solution

1. Step 1: Initialize pointers correctly

   Slow starts at head, fast starts at head.next to find middle for even length lists.

2. Step 2: Loop condition and pointer moves

   Loop while fast and fast.next are not null, move slow by one and fast by two nodes.

3. Final Answer:

   ListNode slow = head, fast = head.next; while(fast != null && fast.next != null) { slow = slow.next; fast = fast.next.next; } -> Option D

4. Quick Check:

   Slow at middle, fast moves twice [OK]

Hint: Start fast one step ahead to split even lists correctly [OK]

Common Mistakes:

• Starting fast at head causing wrong middle
• Incorrect loop conditions causing null pointer
• Moving fast by one instead of two

3. Given the linked list 1 -> 2 -> 3 -> 4 -> 5 -> null, what is the reordered list after applying the reorder algorithm?

medium

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

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

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

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

Solution

1. Step 1: Identify nodes from start and end

   Start with 1 (head), then last node 5, then second node 2, then second last 4, then middle 3.

2. Step 2: Arrange nodes alternately

   Link nodes in order: 1 -> 5 -> 2 -> 4 -> 3 -> null.

3. Final Answer:

   1 -> 5 -> 2 -> 4 -> 3 -> null -> Option A

4. Quick Check:

   Alternate front and back nodes [OK]

Hint: Pick nodes alternately from front and back [OK]

Common Mistakes:

• Reversing entire list instead of reordering
• Skipping middle node placement
• Mixing node order incorrectly

4. Consider this buggy code snippet for reversing the second half of a linked list in reorder operation:

ListNode prev = null;
ListNode curr = mid.next;
while(curr != null) {
  ListNode nextTemp = curr.next;
  curr.next = prev;
  prev = curr;
  curr = nextTemp;
}
mid.next = prev;

What is the likely bug here?

medium

A. The prev pointer is not initialized correctly

B. The loop condition should be while(curr.next != null)

C. The mid.next should be set to null before reversing

D. The reversal logic is correct; no bug present

Solution

1. Step 1: Understand reversal impact on original list

   Before reversing second half, mid.next should be set to null to break the list and avoid cycles.

2. Step 2: Identify missing step causing cycle

   Without setting mid.next = null before reversal, the list may form a cycle causing infinite loops later.

3. Final Answer:

   The mid.next should be set to null before reversing -> Option C

4. Quick Check:

   Break list before reverse to avoid cycles [OK]

Hint: Always cut list at middle before reversing second half [OK]

Common Mistakes:

• Not breaking list causing infinite loops
• Changing loop condition incorrectly
• Misinitializing pointers

5. You have a linked list with nodes 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> null. After reordering, what will be the final list?

hard

A. 1 -> 6 -> 2 -> 5 -> 3 -> 4 -> null

B. 6 -> 5 -> 4 -> 3 -> 2 -> 1 -> null

C. 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> null

D. 1 -> 3 -> 5 -> 2 -> 4 -> 6 -> null

Solution

1. Step 1: Split list into two halves

   First half: 1 -> 2 -> 3, second half: 4 -> 5 -> 6.

2. Step 2: Reverse second half

   Reversed second half: 6 -> 5 -> 4.

3. Step 3: Merge halves alternately

   Merge nodes alternately: 1 -> 6 -> 2 -> 5 -> 3 -> 4 -> null.

4. Final Answer:

   1 -> 6 -> 2 -> 5 -> 3 -> 4 -> null -> Option A

5. Quick Check:

   Alternate front and reversed back nodes [OK]

Hint: Reverse second half, then weave nodes alternately [OK]

Common Mistakes:

• Not reversing second half before merging
• Merging nodes in wrong order
• Forgetting to terminate list properly