Reorder Linked List in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

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

DSA C#

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'

Achild

Bprev

Crandom

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' instead of 'next' causes the pointer to move backwards or fail.

Using 'child' or 'random' which are not standard linked list pointers.

The slow pointer moves one step at a time using the 'next' reference 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 C#

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

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

Anext

Bprev

Cchild

Drandom

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' instead of 'next' causes incorrect traversal.

Using non-existent pointers like 'child' or 'random'.

To reverse the list, we store the next node using 'next', then reverse the pointer.

3fill in blank

hard

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

DSA C#

ListNode first = head;
ListNode second = prev;
while (second.next != null) {
    ListNode temp1 = first.[1];
    ListNode temp2 = second.[2];
    first.[3] = second;
    second.[4] = temp1;
    first = temp1;
    second = temp2;
}

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

Anext

Bprev

Cchild

Drandom

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' causes incorrect pointer assignments.

Mixing different pointer names leads to runtime errors.

All pointer moves and assignments use the 'next' pointer to correctly merge the two halves.

4fill in blank

hard

Fill both blanks to correctly split the list into two halves by breaking the link at the middle.

DSA C#

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

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

Anext

Bprev

Cchild

Drandom

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' instead of 'next' for moving slow pointer.

Not breaking the list properly causes cycles.

We move slow using 'next' and then break the list by setting prev.next to null.

5fill in blank

hard

Fill all three blanks to complete the reorder list function that combines all steps.

DSA C#

public void ReorderList(ListNode head) {
    if (head == null || head.next == null) return;
    ListNode slow = head;
    ListNode fast = head;
    ListNode prev = null;
    while (fast != null && fast.next != null) {
        prev = slow;
        slow = slow.[1];
        fast = fast.next.next;
    }
    prev.[2] = null;
    ListNode second = null;
    ListNode curr = slow;
    ListNode prevNode = null;
    while (curr != null) {
        ListNode nextTemp = curr.[3];
        curr.next = prevNode;
        prevNode = curr;
        curr = nextTemp;
    }
    second = prevNode;
    ListNode first = head;
    while (second != null) {
        ListNode temp1 = first.next;
        ListNode temp2 = second.next;
        first.next = second;
        second.next = temp1;
        first = temp1;
        second = temp2;
    }
}

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

Anext

Bprev

Cchild

Drandom

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect pointers like 'prev' or 'child' causes errors.

Not breaking the list properly leads to infinite loops.

All pointer moves and breaks use the 'next' pointer to correctly reorder the list.

Practice

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

easy

A. Reverse the entire linked list

B. Sort the linked list in ascending order

C. Rearrange the list so nodes alternate from start and end

D. Remove duplicate nodes from the list

Solution

1. Step 1: Understand the problem statement

   The problem asks to reorder the linked list so that nodes are arranged by alternating from the start and the end of the list.

2. Step 2: Differentiate from other operations

   This is not sorting or reversing the whole list, but a specific pattern: first node, last node, second node, second last node, and so on.

3. Final Answer:

   Rearrange the list so nodes alternate from start and end -> Option C

4. Quick Check:

   Reorder means alternate start and end nodes [OK]

Hint: Reorder means alternate nodes from front and back [OK]

Common Mistakes:

• Confusing reorder with sorting
• Thinking reorder means full reversal
• Ignoring the alternating pattern

2. Which of the following C# code snippets correctly declares a singly linked list node class used in reorder linked list problems?

easy

A. public class ListNode { public int val; public ListNode next; public ListNode(int x) { val = x; next = null; } }

B. class Node { int val; Node next; Node(int x) { val = x; next = null; } }

C. public struct ListNode { public int val; public ListNode next; }

D. public class ListNode { int val; ListNode next; ListNode(int x) { val = x; next = null; } }

Solution

1. Step 1: Check for public accessibility and constructor

   public class ListNode { public int val; public ListNode next; public ListNode(int x) { val = x; next = null; } } correctly declares a public class with public fields and a constructor initializing value and next pointer.

2. Step 2: Identify missing public keywords and struct misuse

   Options A and D miss public keywords making fields inaccessible; C uses struct which is not typical for linked list nodes.

3. Final Answer:

   public class ListNode { public int val; public ListNode next; public ListNode(int x) { val = x; next = null; } } -> Option A

4. Quick Check:

   Public class with constructor and public fields [OK]

Hint: Use public class with constructor and public fields [OK]

Common Mistakes:

• Omitting public keyword for fields
• Using struct instead of class
• Missing constructor initialization

3. Given the linked list: 1 -> 2 -> 3 -> 4 -> 5 -> null, what will be the list after applying the reorder linked list 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 the reorder pattern

   The reorder pattern takes first node, last node, second node, second last node, and so on.

2. Step 2: Apply pattern to given list

   Start with 1, then 5, then 2, then 4, then 3 remains in the middle.

3. Final Answer:

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

4. Quick Check:

   Alternate front and back nodes [OK]

Hint: Alternate nodes from front and back [OK]

Common Mistakes:

• Reversing entire list instead of reordering
• Not alternating nodes correctly
• Leaving list unchanged

4. Consider this C# code snippet for reordering a linked list. What is the bug?

public void ReorderList(ListNode head) {
  if (head == null) return;
  ListNode slow = head, fast = head;
  while (fast != null && fast.next != null) {
    slow = slow.next;
    fast = fast.next.next;
  }
  ListNode second = ReverseList(slow);
  ListNode first = head;
  while (second != null) {
    ListNode temp1 = first.next;
    ListNode temp2 = second.next;
    first.next = second;
    second.next = temp1;
    first = temp1;
    second = temp2;
  }
}

medium

A. The ReverseList method is missing

B. The middle node is included in the reversed second half causing cycle

C. The fast pointer initialization is incorrect

D. The loop condition should be while (second.next != null)

Solution

1. Step 1: Analyze slow pointer position after loop

   After the loop, slow points to the middle node, which is included in the reversed second half.

2. Step 2: Understand consequence of including middle node

   Including the middle node causes the merged list to have a cycle or incorrect links because the middle node is connected twice.

3. Final Answer:

   The middle node is included in the reversed second half causing cycle -> Option B

4. Quick Check:

   Exclude middle node before reversing second half [OK]

Hint: Exclude middle node before reversing second half [OK]

Common Mistakes:

• Not splitting list before reversing second half
• Incorrect loop conditions
• Assuming ReverseList is missing error

5. You have a linked list with nodes: 10 -> 20 -> 30 -> 40 -> 50 -> 60 -> null. After applying the reorder linked list algorithm, what is the correct final list?

hard

A. 10 -> 30 -> 50 -> 20 -> 40 -> 60 -> null

B. 60 -> 50 -> 40 -> 30 -> 20 -> 10 -> null

C. 10 -> 20 -> 30 -> 40 -> 50 -> 60 -> null

D. 10 -> 60 -> 20 -> 50 -> 30 -> 40 -> null

Solution

1. Step 1: Identify the reorder pattern for even length list

   For even nodes, reorder alternates first and last nodes: 10, 60, 20, 50, 30, 40.

2. Step 2: Apply the pattern to given list

   Start with 10, then 60, then 20, then 50, then 30, then 40, ending with null.

3. Final Answer:

   10 -> 60 -> 20 -> 50 -> 30 -> 40 -> null -> Option D

4. Quick Check:

   Alternate front and back nodes for even length [OK]

Hint: Alternate nodes from front and back for even length [OK]

Common Mistakes:

• Reversing entire list instead of reordering
• Not handling even length correctly
• Leaving list unchanged