Middle of the Linked List - Practice Coding Problems

Middle of the Linked List - Problem

You're given the head of a singly linked list, and your task is to find and return the middle node of the list.

Here's the catch: if the linked list has an even number of nodes (meaning there are two potential middle nodes), you should return the second middle node.

Example: In a list with nodes [1,2,3,4,5], the middle node is 3. In a list with nodes [1,2,3,4,5,6], there are two middle nodes (3 and 4), so return node 4.

This is a classic problem that tests your understanding of linked list traversal and the elegant two-pointer technique!

Input & Output

example_1.py — Odd Length List

$ Input: [1,2,3,4,5]

› Output: [3,4,5]

💡 Note: The middle node is the 3rd node in the list (value 3). Return the node and all subsequent nodes.

example_2.py — Even Length List

$ Input: [1,2,3,4,5,6]

› Output: [4,5,6]

💡 Note: There are two middle nodes (3 and 4). Since we need the second middle node, return node 4 and all subsequent nodes.

example_3.py — Single Node

$ Input: [1]

› Output: [1]

💡 Note: With only one node, that node is both the head and the middle. Return the single node.

Visualization

Tap to expand

Understanding the Visualization

Start Together

Both slow (🐢) and fast (🐰) pointers begin at the head node

Different Speeds

In each step: slow moves 1 position, fast moves 2 positions

Fast Reaches End

When fast pointer reaches the end or goes beyond, slow is at middle

Perfect Positioning

The slow pointer is guaranteed to be at the middle (or second middle for even length)

Key Takeaway

🎯 Key Insight: The two-pointer technique guarantees that when the fast pointer (moving 2x speed) reaches the end, the slow pointer (moving 1x speed) will be exactly at the middle position. This works for both odd and even length lists!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two traversals of the linked list: O(n) + O(n/2) = O(n)

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to store count and current position

✓ Linear Space

Constraints

The number of nodes in the list is in the range [1, 100]
1 ≤ Node.val ≤ 100

Asked in

a Amazon 45 ⊞ Microsoft 35 G Google 30 f Meta 25

The optimal solution uses the Two Pointers (Tortoise and Hare) technique with O(n) time and O(1) space complexity. By moving the slow pointer one step and fast pointer two steps, when fast reaches the end, slow automatically points to the middle node.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Solution (Count then Find)	O(n)	O(1)	First pass counts nodes, second pass finds the middle
Two Pointers (Tortoise and Hare)	O(n)	O(1)	Fast pointer moves 2 steps, slow pointer moves 1 step - optimal solution

Two-Pass Solution (Count then Find) — Algorithm Steps

Traverse the entire linked list to count total nodes
Calculate middle position: (count / 2) for 0-indexed or (count / 2 + 1) for 1-indexed
Traverse the list again until reaching the middle position
Return the node at middle position

Visualization

Tap to expand

Step-by-Step Walkthrough

Count All Nodes

Traverse entire list counting: 1→2→3→4→5 (count = 5)

Calculate Middle

Middle position = 5/2 = 2 (0-indexed)

Find Middle Node

Traverse to position 2: node with value 3

Code -

solution.c — C

// Definition for singly-linked list.
struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* middleNode(struct ListNode* head) {
    // First pass: count nodes
    int count = 0;
    struct ListNode* current = head;
    while (current) {
        count++;
        current = current->next;
    }
    
    // Second pass: find middle
    int middlePos = count / 2;
    current = head;
    for (int i = 0; i < middlePos; i++) {
        current = current->next;
    }
    
    return current;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two traversals of the linked list: O(n) + O(n/2) = O(n)

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to store count and current position

✓ Linear Space

Constraints

The number of nodes in the list is in the range [1, 100]
1 ≤ Node.val ≤ 100

89.2K Views

High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass Solution (Count then Find) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler