Пузырьковый метод сортировки. Программа на языке Python. Шемаров Денис

Вот корректно отформатированный код с правильными отступами (в Python отступы критически важны — они определяют блоки кода):

python

N = int(input())

l = list()

for _ in range(N):

    l.append(int(input()))

# N = 6

# l = [4, 1, 25, 72, 7, 2]

for i in range(N, 0, -1):

    for j in range(i):

        try:

            if l[j] < l[j + 1]:

                l[j], l[j + 1] = l[j + 1], l[j]

        except Exception:

            ...

print(l)

Пояснения по отступам:

1. Первая строка (N = int(input())) — начало программы, нет отступа.
2. Создание списка (l = list()) — тот же уровень, нет отступа.
3. Цикл for _ in range(N) — после двоеточия идёт отступ в 4 пробела для тела цикла.
4. Тело цикла (l.append(...)) — все строки внутри цикла имеют отступ 4 пробела.
5. Второй цикл for i in range(...) — снова нет отступа перед заголовком, но тело цикла (внутренние строки) имеют отступ 4 пробела.
6. Внутренний цикл for j in range(i) — отступ 4 пробела от внешнего цикла; тело внутреннего цикла — ещё 4 пробела (итого 8 пробелов от начала строки).
7. Блок try — отступ 4 пробела от внутреннего цикла; тело try — ещё 4 пробела (итого 12 пробелов).
8. Условие if — отступ 4 пробела от try; тело if — ещё 4 пробела (итого 16 пробелов).
9. Обмен элементов (l[j], l[j + 1] = ...) — тот же уровень отступа, что и тело if.
10. Блок except — тот же отступ, что и try (4 пробела от внутреннего цикла).
11. Команда print(l) — нет отступа, так как это последняя инструкция после всех циклов.

Важно:

• В Python принято использовать ровно 4 пробела на каждый уровень вложенности (табуляция не рекомендуется).
• Все строки одного блока должны иметь одинаковый отступ.
• Смешивание пробелов и табуляции может привести к ошибкам.

Разберём код пузырьковой сортировки пошагово.

Общий принцип пузырьковой сортировки

Алгоритм последовательно сравнивает соседние элементы массива и меняет их местами, если они расположены в неправильном порядке (в данном случае — если левый элемент меньше правого, т. е. сортировка по убыванию). После каждого полного прохода наибольший («самый лёгкий») элемент «всплывает» на своё место в конце массива.

Разбор кода

1. Ввод данных

python

N = int(input())

l = list()

for _ in range(N):

    l.append(int(input()))

• N — количество элементов в массиве (вводится с клавиатуры).
• Создаётся пустой список l.
• В цикле for считывается N чисел и добавляется в список.

Пример: если ввести 6, а затем числа 4, 1, 25, 72, 7, 2, получится список l = [4, 1, 25, 72, 7, 2].

2. Основной цикл сортировки

python

for i in range(N, 0, -1):

    for j in range(i):

        try:

            if l[j] < l[j+1]:

                l[j], l[j+1] = l[j+1], l[j]

        except Exception: ...

Внешний цикл (for i in range(N, 0, -1)):

• Перебирает значения i от N до 1 (шаг -1).
• На каждой итерации i обозначает границу неотсортированной части массива (справа от i уже отсортированные элементы).

Внутренний цикл (for j in range(i)):

• Проходит по индексам от 0 до i-1.
• Сравнивает пары элементов l[j] и l[j+1].

Условие и обмен:

• Если l[j] < l[j+1] (текущий элемент меньше следующего), элементы меняются местами.
• Обмен выполняется через кортежное присваивание: l[j], l[j+1] = l[j+1], l[j].

Обработка исключений (try/except):

• try пытается выполнить сравнение и обмен.
• except Exception: ... перехватывает возможные ошибки (например, выход за границы списка при j+1 >= len(l)). В данном коде обработка пустая (...), что неидеально, но предотвращает аварийное завершение.

3. Вывод результата

python

print(l)

После завершения сортировки выводится итоговый список.

Пример работы алгоритма

Исходный массив: [4, 1, 25, 72, 7, 2]
Цель: сортировка по убыванию.

Проход 1 (i = 6):
[4, 1, 25, 72, 7, 2] → [4, 25, 72, 7, 2, 1] (72 «всплыл» на последнее место)

Проход 2 (i = 5):
[4, 25, 72, 7, 2, 1] → [25, 72, 7, 4, 2, 1] (25 «всплыл» на предпоследнее место)

…

Итоговый результат: [72, 25, 7, 4, 2, 1].

Недостатки кода

1. Избыточная обработка исключений: блок try/except здесь не нужен, так как индекс j+1 гарантированно существует (внутренний цикл идёт до i-1, а i <= N).
2. Неэффективность: классический пузырьковый метод можно оптимизировать (например, останавливать цикл, если за проход не было обменов).
3. Сортировка по убыванию: обычно пузырьковая сортировка реализует порядок по возрастанию. Здесь логика инвертирована (< вместо >).

Улучшенный вариант (без исключений, по возрастанию)

python

N = int(input())

l = [int(input()) for _ in range(N)]

for i in range(N):

    for j in range(N - i - 1):

        if l[j] > l[j + 1]:

            l[j], l[j + 1] = l[j + 1], l[j]

print(l)