What is the Fast & Slow Pointers pattern?

The Fast & Slow Pointers pattern is a systematic approach to solving a class of coding interview problems. By recognizing the Fast & Slow Pointers structure, you can solve problems in optimal time complexity using proven techniques.

When should I use the Fast & Slow Pointers pattern?

Use the Fast & Slow Pointers pattern when the problem structure matches its recognition signals — typically when brute force would be O(n²) or worse, and the pattern reduces complexity to O(n).

What is the time complexity of Fast & Slow Pointers?

The Fast & Slow Pointers pattern typically runs in O(n) time and uses O(1) space. The exact complexity depends on the specific sub-variant being applied.

Is Fast & Slow Pointers important for coding interviews?

Yes — the Fast & Slow Pointers pattern is frequently tested at FAANG companies and competitive engineering interviews. Mastering this pattern gives you a reliable framework to solve many problem variations quickly.

How do I practice the Fast & Slow Pointers pattern?

Start by studying the pattern's mental model and recognition signals on DSAPatterns, then practice the curated LeetCode problems below in order from Easy to Hard. Aim for pattern recognition before memorizing solutions.

← back to patterns

pattern / MEDIUM

Fast & Slow Pointers.

Use two pointers moving at different speeds

complexity

time

O(n)

space

O(1)

practice questions

browse and solve all 0 pattern questions →

02' — visual

interactive

Sliding window — k = 3

Maximum sum subarray

Window

[0, 2]

Sum

Step

0 / 3

03'

mental
model.

Slow moves 1 step at a time, fast moves 2 steps. If there's a cycle, they'll meet. If no cycle, fast reaches the end.

Also known as the Hare and Tortoise algorithm, this pattern uses two pointers moving at different speeds to detect cycles and find middle elements.

when to use ✓

01Detect cycle in linked list
02Find cycle start
03Find middle of linked list
04Check if palindrome
05Find duplicate number in array

when not ✗

01When traversal order doesn't matter

04'

recognition signals

Cycle detection in linked list

Find middle of linked list

Palindrome linked list

Happy number problem

Cycle detectionFind cycle startFind middlePalindrome check

05'

templates

python

1# Beginner: Fixed-size sliding window
2def max_sum_k(nums, k):
3   n = len(nums)
4   if n < k:
5      return 0
6   window_sum = sum(nums[:k])
7   max_sum = window_sum
8   for i in range(k, n):
9      window_sum += nums[i] - nums[i - k]
10      max_sum = max(max_sum, window_sum)
11   return max_sum

common mistakes

01Not checking for null fast.next before fast.next.next
02Confusing when to move which pointer

interview tips

01Use this for any cycle-related problem
02After finding cycle, reset slow to head and move both 1 step to find cycle start

06'

practice this pattern

0 curated problems from LeetCode

See all

No questions found for this pattern yet.

07'

faq

1# Beginner: Fixed-size sliding window

2def max_sum_k(nums, k):

3 n = len(nums)

4 if n < k:

5 return 0

6 window_sum = sum(nums[:k])

7 max_sum = window_sum

8 for i in range(k, n):

9 window_sum += nums[i] - nums[i - k]

10 max_sum = max(max_sum, window_sum)

11 return max_sum