15 ключевых паттернов LeetCode: от двух указателей до динамического программирования

Введение в алгоритмическую подготовку 2026

Подготовка к алгоритмическим интервью за последние два года претерпела значительные изменения. Если в 2022-2023 годах достаточно было решить 200-300 случайных задач, то сегодня акцент делается на типизацию. Интервьюеры всё чаще дают модифицированные версии классических задач, чтобы проверить, понимает ли кандидат лежащий в основе паттерн или просто заучил решение. Согласно статистике платформы LeetCode за 2025 год, кандидаты, использующие системный подход на основе паттернов, проходят этапы кодинга в 2.4 раза чаще остальных.

Эта статья написана для разработчиков уровня Middle и Senior, которые планируют выход на международный рынок или в топовые российские экосистемы. Мы не будем тратить время на основы синтаксиса, а сосредоточимся на архитектуре алгоритмов. Вы узнаете, как идентифицировать задачу за первые 30 секунд чтения условия и какой шаблон кода применить. Мы разберем всё: от классических двух указателей до продвинутых техник работы с графами и динамическим программированием.

Почему паттерны важнее задач

Количество задач на LeetCode превысило 3500. Пытаться решить их все — путь к выгоранию. Однако количество фундаментальных приемов ограничено. Освоив 15 паттернов, представленных ниже, вы сможете декомпозировать практически любую новую задачу. Это особенно важно в условиях стресса на интервью, когда оперативная память мозга ограничена. Наличие готовых ментальных моделей позволяет сэкономить время на проектировании базовой логики и сосредоточиться на обработке граничных случаев.

1. Паттерн: Два указателя (Two Pointers)

Два указателя — это база, на которой строятся десятки других алгоритмов. Суть заключается в использовании двух переменных-индексов, которые перемещаются по структуре данных (обычно массиву или строке) навстречу друг другу или в одном направлении. В 2026 году этот паттерн остается самым часто встречающимся в задачах категорий Easy и Medium.

Механика работы

Обычно мы используем левый указатель (left) в начале и правый (right) в конце массива. На каждом шаге мы сравниваем значения под указателями и принимаем решение, какой из них сдвинуть. Это позволяет снизить временную сложность с O(N²) до O(N), так как мы проходим по массиву всего один раз.

Когда применять

• Массив отсортирован (это главный индикатор).
• Нужно найти пару элементов, удовлетворяющих условию (например, сумму).
• Требуется перевернуть массив или удалить дубликаты на месте (In-place).

def pair_with_target_sum(arr, target_sum):
    left, right = 0, len(arr) - 1
    while left < right:
        current_sum = arr[left] + arr[right]
        if current_sum == target_sum:
            return [left, right]
        if target_sum > current_sum:
            left += 1  # Нужна сумма больше
        else:
            right -= 1 # Нужна сумма меньше
    return [-1, -1]

2. Скользящее окно (Sliding Window)

Этот паттерн используется для работы с подмассивами или подстроками заданной или переменной длины. Вместо того чтобы пересчитывать значение для каждого окна с нуля, мы «вдвигаем» один элемент справа и «выдвигаем» один слева. Это критически важно для производительности в высоконагруженных системах обработки потоковых данных.

Типы окон

Существует два основных типа: фиксированное окно (например, найти среднее всех подмассивов размера K) и динамическое окно (найти кратчайшую подстроку с определенными символами). Динамическое окно часто комбинируется с хеш-таблицами для отслеживания частоты символов.

Пример: Максимальная сумма подмассива размера K

Вместо вложенного цикла, мы поддерживаем текущую сумму. При переходе к следующему элементу мы добавляем новый и вычитаем тот, который остался позади.

def max_sub_array_of_size_k(k, arr):
    max_sum, window_sum = 0, 0
    window_start = 0
    for window_end in range(len(arr)):
        window_sum += arr[window_end]
        if window_end >= k - 1:
            max_sum = max(max_sum, window_sum)
            window_sum -= arr[window_start]
            window_start += 1
    return max_sum

3. Быстрый и медленный указатели (Fast & Slow Pointers)

Этот метод также известен как алгоритм «Зайца и Черепахи». Он незаменим при работе со связными списками и циклическими структурами данных. Идея в том, что один указатель движется в два раза быстрее другого. Если в структуре есть цикл, быстрый указатель обязательно догонит медленный.

Применение в 2026 году

Помимо детекции циклов, паттерн используется для поиска середины списка за один проход, что актуально для алгоритмов типа Merge Sort на списках. Также он применяется в задачах на «счастливые числа» и проверку палиндромов в односвязных списках.

4. Слияние интервалов (Merge Intervals)

Задачи на интервалы — классика системного дизайна и планировщиков задач. Если вам нужно найти пересечения в календаре или объединить временные отрезки, этот паттерн обязателен. Ключевой шаг здесь — предварительная сортировка интервалов по времени начала.

Алгоритм действий

1. Сортируем список интервалов по start_time.
2. Инициализируем список для результата первым интервалом.
3. Итерируемся по остальным: если текущий интервал пересекается с последним в результате (current.start <= last.end), объединяем их, обновляя last.end.

5. Циклическая сортировка (Cyclic Sort)

Этот паттерн — «секретное оружие» для задач, где дан массив чисел в диапазоне от 1 до N. Если вы видите фразу «найдите пропущенное число» или «найдите дубликат», скорее всего, это Cyclic Sort. Он позволяет отсортировать массив за O(N) времени без использования дополнительной памяти.

Принцип работы

Мы знаем, что число `i` должно находиться на индексе `i-1`. Мы проходим по массиву и, если число не на своем месте, меняем его с тем, что стоит на его «законном» месте. Повторяем, пока текущий индекс не будет содержать правильное число.

def cyclic_sort(nums):
    i = 0
    while i < len(nums):
        j = nums[i] - 1
        if nums[i] != nums[j]:
            nums[i], nums[j] = nums[j], nums[i]
        else:
            i += 1
    return nums

6. Реверс связного списка (In-place Reversal of a LinkedList)

Многие задачи требуют манипуляций со связным списком без выделения дополнительной памяти. Умение развернуть весь список или его часть — базовый навык. В 2026 году интервьюеры часто усложняют задачу, прося развернуть каждый K-й блок или четные позиции.

Ключевые переменные

Вам всегда нужны три указателя: `current`, `previous` и `next`. Главная ошибка новичков — потеря ссылки на `next` перед изменением `current.next`. Всегда сохраняйте временную ссылку.

7. Деревья: BFS и DFS

Обход деревьев и графов — это фундамент. Breadth-First Search (BFS) использует очередь и находит кратчайший путь в невзвешенном графе. Depth-First Search (DFS) использует стек (или рекурсию) и лучше подходит для задач на поиск путей, генерацию комбинаций и проверку связности.

BFS по уровням

Важный нюанс: при обходе по уровням (Level Order Traversal) нужно фиксировать размер очереди в начале каждой итерации цикла `while`, чтобы обработать ровно один уровень за раз.

8. Две кучи (Two Heaps)

Этот паттерн идеален для задач, где нужно постоянно находить медиану или поддерживать баланс между двумя наборами данных. Мы используем Max-Heap для хранения меньшей половины чисел и Min-Heap для большей половины. Таким образом, медиана всегда находится на вершинах куч.

Кейс: Потоковая медиана

В современных финансовых системах (HFT) расчет скользящей медианы цен — стандартная операция. Паттерн Two Heaps позволяет делать вставку за O(log N) и получение медианы за O(1).

9. Подмножества (Subsets)

Задачи на поиск всех возможных комбинаций, перестановок или подмножеств решаются с помощью паттерна Breadth-First Search или Backtracking. В 2026 году важно понимать разницу в производительности: итеративный подход часто выигрывает у рекурсивного из-за отсутствия оверхеда на стек вызовов.

10. Модифицированный бинарный поиск

Если массив отсортирован, но подвергся какой-то трансформации (например, циклический сдвиг), обычный бинарный поиск не сработает напрямую. Однако логику деления диапазона пополам сохранить можно. Это применимо для поиска в бесконечных массивах или поиска ближайшего элемента.

11. Топ 'K' элементов

Любая задача вида «найти 10 самых часто встречающихся слов» или «K ближайших точек к началу координат» решается через кучу (Heap). Вместо полной сортировки за O(N log N), использование кучи размера K дает сложность O(N log K), что критично при больших N.

12. Динамическое программирование: Knapsack

DP остается самым сложным разделом. Паттерн «0/1 Knapsack» (рюкзак) — основа для сотен задач. Суть в принятии решения для каждого элемента: берем мы его или нет, и как это влияет на текущую «стоимость» при ограничении по «весу».

FAQ

В: Сколько паттернов нужно знать для Senior позиций?
О: Минимум 12-15 основных. На этом уровне важно не просто решить задачу, а предложить наиболее оптимальное по памяти решение (O(1) space).

В: Стоит ли использовать Python на интервью в 2026?
О: Да, Python остается стандартом для алгоритмических секций благодаря лаконичности. Однако для системных ролей могут попросить C++ или Rust.

В: Как быстро определить паттерн?
О: Смотрите на входные данные. Отсортированный массив — Two Pointers/Binary Search. Дерево — BFS/DFS. Поиск подстроки — Sliding Window.

Заключение

Подготовка к LeetCode — это марафон, а не спринт. В 2026 году ключом к успеху является не количество решенных задач, а качество понимания паттернов. Начните с «Двух указателей» и «Скользящего окна», так как они встречаются в 40% случаев. Помните, что на реальном интервью ваша способность рассуждать вслух и анализировать сложность алгоритма ценится выше, чем идеально написанный код с первой попытки.