---
title: Reverse Linked List
difficulty: Easy
category: Linked List
leetcode_id: 206
revision_count: 1
last_revision: 2026-09-12
---

# Reverse Linked List

> **LeetCode:** [#206](https://leetcode.com/problems/reverse-linked-list/)
> **Сложность:** Easy
> **Категория:** Linked List

## Условие

Дан головной узел односвязного списка. Развернуть список и вернуть его новую голову (последний узел исходного списка).

```
Input:  head = [1,2,3,4,5]  →  Output: [5,4,3,2,1]
Input:  head = [1,2]        →  Output: [2,1]
Input:  head = []           →  Output: []
```

## Ключевая идея

Идём по списку одним проходом, переворачивая указатель `next` каждого узла в обратную сторону. Три переменные: `prev` (уже развёрнутая часть), `curr` (текущий узел), `next` (сохранённый хвост, чтобы не потерять список после разворота указателя). В конце `prev` — новая голова.

## Оценка сложности

- **Время:** O(n) — один проход по списку
- **Память:** O(1) — только три указателя, без доп. структур

## Решение (Ruby)

```ruby
# Определение ListNode дано в LeetCode:
# class ListNode
#   attr_accessor :val, :next
#   def initialize(val = 0, _next = nil)
#     @val, @next = val, _next
#   end
# end

# @param {ListNode} head
# @return {ListNode}
def reverse_list(head)
  prev = nil
  curr = head

  while curr
    nxt = curr.next   # сохраняем хвост до разворота
    curr.next = prev  # разворачиваем указатель
    prev = curr       # сдвигаем prev вперёд
    curr = nxt        # сдвигаем curr вперёд
  end

  prev
end
```

### Рекурсивный вариант (на случай, если спросят)

```ruby
# @param {ListNode} head
# @return {ListNode}
def reverse_list(head)
  return head if head.nil? || head.next.nil?

  new_head = reverse_list(head.next)
  head.next.next = head  # следующий узел указывает назад на текущий
  head.next = nil        # текущий становится хвостом
  new_head
end
```

## Разбор на примере

```
Input: head = [1,2,3,4,5]

Итерация 1: curr = 1
  nxt = 2, 1.next = nil (prev) → prev = 1, curr = 2
  Список: nil ← 1   2 → 3 → 4 → 5
Итерация 2: curr = 2
  nxt = 3, 2.next = 1 → prev = 2, curr = 3
  Список: nil ← 1 ← 2   3 → 4 → 5
Итерация 3: curr = 3
  nxt = 4, 3.next = 2 → prev = 3, curr = 4
  Список: nil ← 1 ← 2 ← 3   4 → 5
Итерация 4: curr = 4
  nxt = 5, 4.next = 3 → prev = 4, curr = 5
  Список: nil ← 1 ← 2 ← 3 ← 4   5
Итерация 5: curr = 5
  nxt = nil, 5.next = 4 → prev = 5, curr = nil

Цикл завершён (curr == nil). Result: prev = 5 → 4 → 3 → 2 → 1
```

## Edge Cases

- **Пустой список**: `head = nil` → цикл не выполняется, возвращаем `prev = nil`.
- **Один узел**: `head = [1]` → одна итерация, `1.next = nil`, возвращаем узел 1.
- **Два узла**: `[1,2]` → `2.next = 1`, `1.next = nil`, возвращаем 2.
- **Отрицательные значения**: не влияют — мы не сравниваем значения, только перелинковываем узлы.

## Типичные ошибки

1. ❌ **Забыть сохранить `nxt` перед `curr.next = prev`** — после разворота указателя хвост теряется, цикл обрывается.
2. ❌ **Возвращать `curr` вместо `prev`** — в конце цикла `curr == nil`, голова развёрнутого списка — это `prev`.
3. ❌ **Старый head указывает на nil только неявно** — у исходного хвоста `next` должен стать nil; в итеративном решении это происходит автоматически (последний узел получает `prev` = предыдущий, а исходный head получает `next = nil` на первой итерации).
4. ❌ **Рекурсия без базового случая** — `head.nil? || head.next.nil?` обязателен, иначе переполнение стека на пустом/одноэлементном списке.

## Альтернативные подходы

| Подход | Время | Память | Комментарий |
|--------|-------|--------|-------------|
| Собрать в массив и перелинковать в обратном порядке | O(n) | O(n) | Просто, но лишняя память под весь список |
| **Итеративный prev/curr/next** | **O(n)** | **O(1)** | **финальное решение** — стандарт интервью |
| Рекурсивный | O(n) | O(n) | Красивый, но стек рекурсии + риск переполнения на длинных списках |

Итеративный вариант — самый надёжный: O(1) памяти, без риска StackOverflow. Рекурсию держим в голове как запасной вариант, если спросят «а можно без цикла?».

## Заметки после повторения

_— Заполняется после каждой тренировки._