Find Middle Element of Linked List in DSA C# - Time & Space Complexity

Time Complexity: Find Middle Element of Linked List

O(n)

Understanding Time Complexity

We want to understand how long it takes to find the middle element in a linked list as the list grows.

How does the time needed change when the list gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

public class Node {
    public int Value;
    public Node Next;
}

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

This code finds the middle node of a linked list by moving two pointers at different speeds.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The while loop that moves the fast and slow pointers through the list.
• How many times: The loop runs about half the number of nodes in the list (n/2 times).

How Execution Grows With Input

As the list size grows, the number of steps grows roughly half as fast.

Input Size (n)	Approx. Operations
10	About 5 steps
100	About 50 steps
1000	About 500 steps

Pattern observation: The steps grow linearly with the size of the list, just half as many steps as nodes.

Final Time Complexity

Time Complexity: O(n)

This means the time to find the middle grows directly in proportion to the list size.

Common Mistake

[X] Wrong: "The loop runs n times, so it takes twice as long as needed."

[OK] Correct: The fast pointer moves two steps each time, so the loop only runs about n/2 times, which is still linear time.

Interview Connect

Understanding this pattern helps you quickly analyze linked list problems and shows you can reason about pointer movement efficiently.

Self-Check

"What if we used only one pointer moving one step at a time? How would the time complexity change?"

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