Find Middle Element of Linked List in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new node with the given value.

DSA C#

Node newNode = new Node([1]);

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

Avalue

Bnode

Cnull

Dhead

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'node' instead of the value.

Passing 'null' which creates an empty node.

Using 'head' which is the start of the list, not the new value.

The constructor of Node requires the value to store in the node.

2fill in blank

medium

Complete the code to move the slow pointer one step forward in the linked list.

DSA C#

slow = slow[1];

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

A.value

B.prev

C.head

D.next

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' which is for doubly linked lists.

Using 'head' which resets the pointer to the start.

Using 'value' which is data, not a pointer.

To move forward in a singly linked list, use the 'next' pointer.

3fill in blank

hard

Fix the error in the while loop condition to correctly find the middle node.

DSA C#

while (fast != null && fast[1] != null) {

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

A.next

B.prev

C.value

D.head

Attempts:

3 left

💡 Hint

Common Mistakes

Checking fast.prev which does not exist in singly linked list.

Checking fast.value which is data, not a pointer.

Checking fast.head which is invalid.

The fast pointer moves two steps, so we check fast.next to avoid null reference.

4fill in blank

hard

Fill both blanks to correctly move the fast pointer two steps ahead.

DSA C#

fast = fast[1]; fast = fast[2];

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

A.next

B.prev

C.value

D.head

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'prev' which is not in singly linked list.

Using 'value' which is data, not a pointer.

Using 'head' which resets pointer.

To move two steps forward, move fast to fast.next, then fast.next again.

5fill in blank

hard

Fill the blank to return the data of the middle node.

DSA C#

return slow[1];

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

A.data

B.next

C.value

D.head

Attempts:

3 left

💡 Hint

Common Mistakes

Using '.next' which is a pointer to next node, not data.

Using '.data' which may not be the property name in this implementation.

Using '.head' which is invalid here.

The middle node's data is accessed by the 'value' property.

Practice

1. What is the main idea behind finding the middle element of a singly linked list using the two-pointer technique?

easy

A. Reverse the list and pick the first element

B. Count all nodes first, then access the middle by index

C. Use two pointers moving at the same speed until they meet

D. Use one slow pointer moving one step and one fast pointer moving two steps until fast reaches the end

Solution

1. Step 1: Understand two-pointer movement

   The slow pointer moves one node at a time, while the fast pointer moves two nodes at a time.

2. Step 2: Identify middle when fast pointer ends

   When the fast pointer reaches the end (null), the slow pointer will be at the middle node.

3. Final Answer:

   Use one slow pointer moving one step and one fast pointer moving two steps until fast reaches the end -> Option D

4. Quick Check:

   Two-pointer technique = slow one step, fast two steps [OK]

Hint: Move fast pointer twice as fast as slow to find middle [OK]

Common Mistakes:

• Moving both pointers at the same speed
• Not checking for null before moving fast pointer
• Counting nodes first instead of using pointers

2. Which of the following C# code snippets correctly initializes two pointers to find the middle of a linked list named head?

easy

A. ListNode slow = head; ListNode fast = head;

B. ListNode slow = null; ListNode fast = head;

C. ListNode slow = head.next; ListNode fast = head.next.next;

D. ListNode slow = head; ListNode fast = null;

Solution

1. Step 1: Check pointer initialization

   Both slow and fast pointers should start at the head of the list to traverse correctly.

2. Step 2: Validate options

   Only ListNode slow = head; ListNode fast = head; initializes both pointers at head, allowing proper traversal.

3. Final Answer:

   ListNode slow = head; ListNode fast = head; -> Option A

4. Quick Check:

   Both pointers start at head [OK]

Hint: Start both pointers at head to traverse linked list [OK]

Common Mistakes:

• Starting slow or fast pointer at null
• Starting fast pointer too far ahead causing null errors
• Using head.next without checking for null

3. What will be the output of the following C# code that finds the middle element of a linked list?

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

ListNode head = new ListNode(10);
head.next = new ListNode(20);
head.next.next = new ListNode(30);
head.next.next.next = new ListNode(40);
head.next.next.next.next = new ListNode(50);

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

medium

A. 30

B. 20

C. 40

D. 50

Solution

1. Step 1: Trace pointer movement

   Initial: slow=10, fast=10
   Iteration 1: slow=20, fast=30
   Iteration 2: slow=30, fast=50
   Iteration 3: fast.next is null, loop ends.

2. Step 2: Identify middle element

   Slow pointer is at node with value 30, which is the middle of the list.

3. Final Answer:

   30 -> Option A

4. Quick Check:

   Middle element = 30 [OK]

Hint: Slow pointer lands on middle when fast reaches end [OK]

Common Mistakes:

• Assuming middle is 20 or 40 without tracing
• Not checking fast.next before moving fast
• Confusing slow and fast pointer positions

4. The following code is intended to find the middle element of a linked list but throws a NullReferenceException. What is the error?

ListNode slow = head;
ListNode fast = head;
while (fast.next != null && fast.next.next != null) {
  slow = slow.next;
  fast = fast.next.next;
}
Console.WriteLine(slow.val);

medium

A. The fast pointer should start at head.next

B. The slow pointer should move two steps instead of one

C. The while condition should check if fast is null before fast.next

D. The loop should run while fast != null only

Solution

1. Step 1: Analyze while loop condition

   The condition checks fast.next and fast.next.next but does not check if fast itself is null, which can cause NullReferenceException.

2. Step 2: Correct condition order

   Check if fast != null before accessing fast.next to avoid exceptions.

3. Final Answer:

   The while condition should check if fast is null before fast.next -> Option C

4. Quick Check:

   Check fast != null before fast.next to avoid errors [OK]

Hint: Always check pointer is not null before accessing next [OK]

Common Mistakes:

• Checking fast.next before fast itself
• Moving slow pointer incorrectly
• Starting fast pointer at wrong node

5. Given a singly linked list with an even number of nodes, how can you modify the two-pointer approach to return the first middle node instead of the second middle node?

hard

A. Move slow pointer two steps and fast pointer one step in the loop

B. Start fast pointer at head.next and slow at head, with the usual loop condition

C. Change the loop condition to 'while (fast.next != null && fast.next.next != null)' and move slow inside the loop

D. Use a stack to store nodes and pop half to get the first middle

Solution

1. Step 1: Understand default behavior

   Normally, the two-pointer method returns the second middle node for even-length lists.

2. Step 2: Modify pointer start positions

   Starting the fast pointer at head.next and slow at head with the usual loop condition causes the slow pointer to stop at the first middle node.

3. Final Answer:

   Start fast pointer at head.next and slow at head, with the usual loop condition -> Option B

4. Quick Check:

   Adjust pointer start positions to get first middle [OK]

Hint: Start fast one step ahead to get first middle [OK]

Common Mistakes:

• Swapping slow and fast pointer speeds incorrectly
• Starting fast pointer at wrong node
• Using extra data structures unnecessarily