🧠 Problem Statement (Short): Given the head of a singly linked list, return the middle node.
If there are two middle nodes (even length), return the second one.

💡 Approach: Two-Pointer Technique

We use two pointers — slow and fast.

slow moves one step at a time.
fast moves two steps at a time.
When fast reaches the end, slow will be at the middle.

🔁 Why it works:

If one pointer moves twice as fast as the other, then by the time the fast one reaches the end, the slow one is halfway through.

⚙️ C++ Code

class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        ListNode *slow = head;
        ListNode *fast = head;

        while (fast != nullptr && fast->next != nullptr) {
            slow = slow->next;
            fast = fast->next->next;
        }

        return slow;
    }
};

🚩 Key Points to Remember

✅ Always use: while (fast != nullptr && fast->next != nullptr) to avoid null pointer crashes.
✅ If the list has even number of nodes, this returns the second middle node — which is what LeetCode expects.
✅ Constant space: no extra memory used.

📈 Time and Space Complexity

Time: O(n)

Even if we skip steps, we still have to look at each node once or skip over it — so traversal-based logic in linked lists = O(n)

Space: O(1)

We use only two pointers (slow and fast) and no extra data structures — hence constant space.

🧠 Analogy (optional, personal touch)

Think of two brothers running on the same track:

The younger brother (slow) takes one step at a time.
The older brother (fast) takes two steps.
When the older finishes the race, the younger is halfway there — that's your middle.

🧵 Conclusion

This pattern is super handy and comes up in problems like:

Detecting cycles in linked lists
Finding the Kth node from the end
Splitting a list in half

Keep this technique in your DSA toolkit 💼

Find the Middle of a Linked List — Explained with Two Pointers (C++ Code + Intuition)

Table of contents