Find Middle Element of Linked List in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Find the middle element output for odd length list

What is the output of the following C# code that finds the middle element of a linked list with 5 nodes?

DSA C#

public class Node {
    public int data;
    public Node next;
    public Node(int d) { data = d; next = null; }
}

public class LinkedList {
    public Node head;

    public int FindMiddle() {
        Node slow = head, fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow.data;
    }
}

LinkedList list = new LinkedList();
list.head = new Node(10);
list.head.next = new Node(20);
list.head.next.next = new Node(30);
list.head.next.next.next = new Node(40);
list.head.next.next.next.next = new Node(50);

System.Console.WriteLine(list.FindMiddle());

A 40

B 20

C 30

D 50

💡 Hint

Use two pointers: one moves one step, the other moves two steps.

The slow pointer moves one step at a time, fast pointer moves two steps. When fast reaches the end, slow is at the middle. For 5 nodes, middle is the 3rd node with value 30.

❓ Predict Output

intermediate

Find the middle element output for even length list

What is the output of the following C# code that finds the middle element of a linked list with 6 nodes?

DSA C#

public class Node {
    public int data;
    public Node next;
    public Node(int d) { data = d; next = null; }
}

public class LinkedList {
    public Node head;

    public int FindMiddle() {
        Node slow = head, fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow.data;
    }
}

LinkedList list = new LinkedList();
list.head = new Node(5);
list.head.next = new Node(10);
list.head.next.next = new Node(15);
list.head.next.next.next = new Node(20);
list.head.next.next.next.next = new Node(25);
list.head.next.next.next.next.next = new Node(30);

System.Console.WriteLine(list.FindMiddle());

A 20

B 15

C 25

D 30

💡 Hint

For even length, the middle is the second of the two middle nodes.

With 6 nodes, the slow pointer ends at the 4th node (value 20) when fast pointer reaches the end.

🔧 Debug

advanced

Identify the error in middle element code

What error does the following C# code produce when trying to find the middle element of a linked list?

DSA C#

public class Node {
    public int data;
    public Node next;
    public Node(int d) { data = d; next = null; }
}

public class LinkedList {
    public Node head;

    public int FindMiddle() {
        Node slow = head, fast = head.next;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow.data;
    }
}

LinkedList list = new LinkedList();
list.head = new Node(1);
list.head.next = new Node(2);
list.head.next.next = new Node(3);
list.head.next.next.next = new Node(4);
list.head.next.next.next.next = new Node(5);

System.Console.WriteLine(list.FindMiddle());

A Output is 4

B NullReferenceException

C Compilation error

D Output is 3

💡 Hint

Check initialization of fast pointer and loop condition.

Starting fast at head.next causes fast.next.next to be called when fast is null, causing NullReferenceException.

🧠 Conceptual

advanced

Why use two pointers to find middle element?

Why is the two-pointer technique (slow and fast pointers) preferred to find the middle element of a linked list?

A It finds the middle element in a single pass with O(n) time and O(1) space

B It uses extra memory to store nodes for faster access

C It sorts the linked list first to find the middle element

D It requires multiple passes to count nodes then find middle

💡 Hint

Think about time and space efficiency.

Two pointers move through the list once, slow pointer ends at middle. No extra memory needed.

❓ Predict Output

expert

Output of middle element after modifying linked list

What is the output of the following C# code after removing the middle element from the linked list?

DSA C#

public class Node {
    public int data;
    public Node next;
    public Node(int d) { data = d; next = null; }
}

public class LinkedList {
    public Node head;

    public int FindMiddle() {
        Node slow = head, fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow.data;
    }

    public void RemoveMiddle() {
        if (head == null || head.next == null) {
            head = null;
            return;
        }
        Node slow = head, fast = head, prev = null;
        while (fast != null && fast.next != null) {
            prev = slow;
            slow = slow.next;
            fast = fast.next.next;
        }
        prev.next = slow.next;
    }
}

LinkedList list = new LinkedList();
list.head = new Node(1);
list.head.next = new Node(2);
list.head.next.next = new Node(3);
list.head.next.next.next = new Node(4);
list.head.next.next.next.next = new Node(5);

list.RemoveMiddle();
System.Console.WriteLine(list.FindMiddle());

A 5

B 3

C 2

D 4

💡 Hint

After removing the middle, the list has 4 nodes. Find the new middle.

Original middle 3 is removed. New list: 1->2->4->5. Middle is now 4 (the 3rd node).

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