Middle of Linked List in C, C++, Java & Python – Code with Explanation & Examples in Short and Simple

   

C Program

struct Node {
    int val;
    struct Node* next;
};

struct Node* middle(struct Node* head) {
    struct Node *slow = head, *fast = head;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

C Output

Input: 1 → 2 → 3 → 4 → 5  
Output: 3

C++ Program

struct Node {
    int val;
    Node* next;
    Node(int x) : val(x), next(nullptr) {}
};

Node* middle(Node* head) {
    Node *slow = head, *fast = head;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

C++ Output

Input: 1 → 2 → 3 → 4  
Output: 3

JAVA Program

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

Node middle(Node head) {
    Node slow = head, fast = head;
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    return slow;
}

JAVA Output

Input: 1 → 2 → 3 → 4 → 5 → 6  
Output: 4

Python Program

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

def middle(head):
    slow = fast = head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
    return slow

Python Output

Input: 1 → 2 → 3 → 4 → 5  
Output: 3

In-Depth Explanation

Example

Suppose you have a linked list: 1 → 2 → 3 → 4 → 5. Obviously, the middle is 3. But how do you find it without knowing the length?

You employ two pointers:

slow goes one step at a time

fast goes two steps at a time

When the fast runs to the end, the slow will be at the middle. If the list is even, such as 1 → 2 → 3 → 4, then the slow falls on 3, the second middle node — as expected.

Real-Life Analogy

Suppose two people are walking a track — one of them walks slowly, and the other jogs. If the jogger is twice as fast, when each of them completes the track, the slower one will be half-done. That's precisely what we do when we locate the midpoint of a linked list using two pointers.

It's similar to measuring halfway without actually counting — just comparing the distance by which someone is ahead.

Why It Matters

This is a traditional application of the two-pointer pattern — clean and memory-safe. It protects you from going over the list twice or having an additional memory area for storing nodes. This approach is also the foundation for more complex problems such as:

Finding palindrome lists

Reversing the second half

Splitting linked lists

Cycle detection

What You Learn from This

You see how to utilize multiple pointers at the same time to create O(n) solutions with no additional space. It teaches control flow through conditions and pointer traversal — essential for manipulation of linked lists. This technique serves as the groundwork for anyone who seeks to become an expert in pointer-based algorithms.

Interview Relevance and Real Projects

This problem is a classic for coding interviews and tends to lead to subsequent queries such as:

Reverse the second half

Is the list a palindrome?

Merge from the center outwards

It aids in real-world projects such as:

Divide workloads (split a process into half)

Handling queues or streams

Balancing interconnected data for easy access

SEO-Optimized Explanation

Two-pointer method to find the middle of a linked list is an important data structure technique applied in numerous real-world algorithms. The technique is to apply a slow and a fast pointer to find the middle in a single pass, and hence it is very efficient with O(n) time and O(1) space. It is a popular algorithm used in interview questions and practical systems that have balanced data access, e.g., queue management, stream processing, memory-constraint task scheduling. Mastering middle-of-linked-list logic in C, C++, Java, and Python is essential for improving algorithmic thinking and passing technical interviews confidently.