Тройная сортировка: освоение искусства алгоритмов сортировки

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

  1. Пузырьковая сортировка.
    Начнем с классического алгоритма пузырьковой сортировки. Представьте, что у вас есть массив чисел, и ваша задача — отсортировать их по возрастанию. Пузырьковая сортировка работает путем многократной замены соседних элементов, если они расположены в неправильном порядке. Вот простая реализация на Python:
def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr
  1. Сортировка вставками.
    Далее идет сортировка вставками, которая похожа на то, как мы сортируем игральные карты. Начинаем с пустой левой руки и по одной выбираем карты из правой руки, вставляя их в правильное положение в левую руку. Вот реализация Python:
def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
    return arr
  1. Сортировка выбором.
    Давайте рассмотрим сортировку выбором, которая работает путем многократного поиска минимального элемента в неотсортированной части массива и помещения его в начало. Это все равно, что найти самый маленький предмет в куче и положить его сверху. Вот реализация Python:
def selection_sort(arr):
    for i in range(len(arr)):
        min_idx = i
        for j in range(i+1, len(arr)):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr
  1. Сортировка слиянием.
    Теперь давайте углубимся в более эффективный алгоритм, называемый сортировкой слиянием. Он следует подходу «разделяй и властвуй», многократно разделяя массив на две половины, сортируя их, а затем снова объединяя. Вот реализация Python:
def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        left_half = arr[:mid]
        right_half = arr[mid:]

        merge_sort(left_half)
        merge_sort(right_half)

        i = j = k = 0

        while i < len(left_half) and j < len(right_half):
            if left_half[i] < right_half[j]:
                arr[k] = left_half[i]
                i += 1
            else:
                arr[k] = right_half[j]
                j += 1
            k += 1

        while i < len(left_half):
            arr[k] = left_half[i]
            i += 1
            k += 1

        while j < len(right_half):
            arr[k] = right_half[j]
            j += 1
            k += 1

    return arr
  1. Быстрая сортировка.
    Еще один популярный алгоритм сортировки — быстрая сортировка. Он также использует стратегию «разделяй и властвуй», но выбирает «поворотный» элемент и разбивает массив вокруг него. Элементы, меньшие, чем ось, перемещаются влево, а элементы, превышающие ось, перемещаются вправо. Вот реализация Python:
def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)
  1. Кучная сортировка.
    Кучная сортировка использует преимущества структуры данных, называемой двоичной кучей. Сначала он создает кучу из массива, а затем неоднократно извлекает максимальный элемент и помещает его в конец отсортированной части массива. Вот реализация Python:
def heapify(arr, n, i):
    largest = i
    left = 2 * i + 1
    right = 2 * i + 2
   if left < n and arr[i] < arr[left]:
        largest = left
    if right < n and arr[largest] < arr[right]:
        largest = right
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)

def heap_sort(arr):
    n = len(arr)
    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)
    for i in range(n - 1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]
        heapify(arr, i, 0)
    return arr
  1. Поразрядная сортировка.
    Поразрядная сортировка — это алгоритм несравнительной сортировки, который сортирует числа путем обработки отдельных цифр. Он начинается с сортировки чисел по младшей значащей цифре и постепенно движется к наиболее значимой цифре. Вот реализация Python:
def radix_sort(arr):
    max_value = max(arr)
    exp = 1
    while max_value // exp > 0:
        count = [0] * 10
        output = [0] * len(arr)
        for num in arr:
            count[(num // exp) % 10] += 1
        for i in range(1, 10):
            count[i] += count[i - 1]
        for i in range(len(arr) - 1, -1, -1):
            output[count[(arr[i] // exp) % 10] - 1] = arr[i]
            count[(arr[i] // exp) % 10] -= 1
        for i in range(len(arr)):
            arr[i] = output[i]

        exp *= 10
    return arr
  1. Сортировка с подсчетом.
    Сортировка с подсчетом — это эффективный алгоритм сортировки целых чисел, когда диапазон входных значений известен заранее. Он работает путем подсчета вхождений каждого уникального элемента, а затем определения правильной позиции для каждого элемента в отсортированном выходном массиве. Вот реализация Python:
def counting_sort(arr):
    max_value = max(arr)
    count = [0] * (max_value + 1)
    output = [0] * len(arr)
    for num in arr:
        count[num] += 1
    for i in range(1, len(count)):
        count[i] += count[i - 1]
    for i in range(len(arr) - 1, -1, -1):
        output[count[arr[i]] - 1] = arr[i]
        count[arr[i]] -= 1
    for i in range(len(arr)):
        arr[i] = output[i]
    return arr

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