Finding the Middle of a Singly Linked List: The Classic Fast and Slow Pointer Technique

Table of Contents

Problem Description Solution Approach Fast and Slow Pointer Method Why exactly in the middle?The “second middle node” for even lengths Algorithm Steps Code Implementation Illustrated Process Odd length: n = 5 Even length: n = 6 Complexity Analysis Fast and Slow Pointer Pattern Summary Key Points

805 words

4 minutes

Finding the Middle of a Singly Linked List: The Classic Fast and Slow Pointer Technique

2026-08-10

Algorithms

Linked List

/

Fast and Slow Pointers

/

Two Pointers

/

C

/

C++

/

JavaScript

Problem Description#

Given the head node head of a singly linked list, return the middle node of the linked list. If there are two middle nodes (the linked list length is even), return the second middle node.

1
Input: head = 1→2→3→4→5
2
Output: 3→4→5
3
Explanation: Node 3 is the middle node
4

5
Input: head = 1→2→3→4→5→6
6
Output: 4→5→6
7
Explanation: There are two middle nodes (3 and 4), return the second one, i.e., node 4

Solution Approach#

Fast and Slow Pointer Method#

Imagine two people running, where A’s speed is twice that of B. When A finishes the entire course, B has run exactly half the distance.

Mapped to a linked list:

slow moves one step at a time
fast moves two steps at a time
When fast reaches the end of the linked list (null) or cannot move two steps, slow is exactly at the middle position

Why exactly in the middle?#

Let the linked list length be n, slow has walked s steps, fast has walked 2s steps.

When fast reaches the end (the nth node or beyond), 2s ≈ n, so s ≈ n/2
slow has walked exactly n/2 steps, located at the middle position

The “second middle node” for even lengths#

The problem requires returning the second middle node. The fast and slow pointers naturally satisfy this requirement:

When n=6, slow reaches the 4th node (after 3 steps), which is exactly the second middle node ✓

Algorithm Steps#

Initialize slow = fast = head
Loop condition: while (fast && fast->next)
Each round: slow moves one step, fast moves two steps
After the loop ends, return slow

Why is the loop condition fast && fast->next? Because fast needs to move two steps each time, we need to ensure that both the current node and the next node are not null. When the fast pointer cannot move two steps, the slow pointer has already reached the midpoint.

Code Implementation#

1
#include <stdio.h>
2
#include <stdlib.h>
3

4
typedef struct ListNode {
5
    int val;
6
    struct ListNode *next;
7
} ListNode;
8

9
ListNode* middleNode(ListNode* head) {
10
    ListNode *slow = head;
11
    ListNode *fast = head;
12

13
    //fast moves two steps at a time, slow moves one step at a time
14
    while (fast && fast->next) {
15
        slow = slow->next;
16
        fast = fast->next->next;
17
    }
18

19
    //When fast reaches the end, slow is exactly at the midpoint
20
    return slow;
21
}

1
struct ListNode {
2
    int val;
3
    ListNode *next;
4
    ListNode() : val(0), next(nullptr) {}
5
    ListNode(int x) : val(x), next(nullptr) {}
6
    ListNode(int x, ListNode *next) : val(x), next(next) {}
7
};
8

9
class Solution {
10
public:
11
    ListNode* middleNode(ListNode* head) {
12
        ListNode *slow = head;
13
        ListNode *fast = head;
14

15
        //fast moves two steps at a time, slow moves one step at a time
16
        while (fast && fast->next) {
17
            slow = slow->next;
18
            fast = fast->next->next;
19
        }
20

21
        //When fast reaches the end, slow is exactly at the midpoint
22
        return slow;
23
    }
24
};

1
class ListNode {
2
    constructor(val, next) {
3
        this.val = (val === undefined ? 0 : val);
4
        this.next = (next === undefined ? null : next);
5
    }
6
}
7

8
function middleNode(head) {
9
    let slow = head;
10
    let fast = head;
11

12
    //fast moves two steps at a time, slow moves one step at a time
13
    while (fast && fast.next) {
14
        slow = slow.next;
15
        fast = fast.next.next;
16
    }
17

18
    //When fast reaches the end, slow is exactly at the midpoint
19
    return slow;
20
}

Illustrated Process#

Odd length: n = 5#

1
Initial:   slow            slow              slow
2
           fast            fast              fast
3
           ↓               ↓                 ↓
4
           1 → 2 → 3 → 4 → 5
5
           ↑               ↑                 ↑
6

7
Step 0:    slow=1, fast=1
8
Step 1:    slow=2, fast=3
9
Step 2:    slow=3, fast=5
10
Step 3:    fast.next==null → exit loop
11
           return slow=3 (middle point) ✓

Even length: n = 6#

1
Initial:   slow            slow              slow
2
           fast            fast              fast
3
           ↓               ↓                 ↓
4
           1 → 2 → 3 → 4 → 5 → 6 → null
5
           ↑               ↑             ↑
6

7
Step 0:    slow=1, fast=1
8
Step 1:    slow=2, fast=3
9
Step 2:    slow=3, fast=5
10
Step 3:    slow=4, fast=null → exit loop
11
           return slow=4 (the second middle node) ✓

Complexity Analysis#

Dimension	Analysis
Time Complexity	O(n) — Traverses the linked list only once
Space Complexity	O(1) — Only two pointers are used

Fast and Slow Pointer Pattern Summary#

Fast and slow pointers are one of the most commonly used techniques in linked list problems. The core pattern:

1
while (fast && fast->next) {
2
    slow = slow->next;       // slow pointer moves one step
3
    fast = fast->next->next; // fast pointer moves two steps
4
}
5
// at this point slow points to the midpoint

This pattern is also used to solve:

Cycle detection (Floyd’s cycle-finding algorithm)
Finding the start of a cycle
Palindrome linked list check (find the midpoint, then reverse the second half)

Key Points#

Loop condition fast && fast->next: Ensures the fast pointer can move two steps each time without null pointer errors
Even length returns the second midpoint: This is the natural result of fast and slow pointers, requiring no extra handling
Single traversal O(n): Better than the two-pass method of “first find the length, then walk n/2 steps”