Все виды сортировок.

###Сортировка пузырьком. Идем последовательно, сравнивая каждый элемент с соседом. Кол-во итераций здесь n - 1 (просто запомнить этот факт). Делаю n - i - 1, так как на 1 число каждый раз меньше рассматривать, после 1 итерации выйдет max в конец. flag сделал для более высокой скорости кода, если будет уже все отсортировано меньше, чем за n-1.
def bubble_sort(lst):
    n = len(lst)
    for i in range(n - 1):
        flag = True
        for j in range(n - i - 1):
            if lst[j] > lst[j + 1]:
                lst[j], lst[j + 1] = lst[j + 1], lst[j]
                flag = False
        if flag == True:
            break
    return lst

###Сортировка выбором. Находим минимальное значение в списке, достаем индекс, удаляем его (pop() возвращает значение), а потом добавляем в конец списка. С помощью среза перестаю рассматривать последний элемент и т.д.
def selection_sort(lst):
    for k in range(len(lst), 0, -1):
        lst.append(lst.pop(lst.index(min(lst[:k]))))
    return lst


def selection_sort_ver2(lst: list[int]) -> list[int]:
    """
    Сортировка списка методом выбора
    :param lst: список, состоящий из чисел
    :return: отсортированный список
    """
    for min_pos in range(len(lst) - 1):
        for k in range(min_pos + 1, len(lst)):
            if lst[k] < lst[min_pos]:
                lst[k], lst[min_pos] = lst[min_pos], lst[k]
    return lst


###Сортировка вставкой. Здесь мы берем элемент и сравниваем с прошлыми до самого начала. Самый минимальный сразу станет в начало. Идем последовательно слева-направо.
def s_insert(lst):
    for i in range(1, len(lst)):
        for j in range(i,0,-1):
            if lst[j] < lst[j-1]:
                lst[j], lst[j-1] = lst[j-1], lst[j]
            else:
                break
    return lst

### Сортировка Шелла. Здесь мы берем и сравниваем элементы на расстоянии, начиная с n//2 и уменьшая данное расстояние в два раза.
def shell_sort(lst):
    move = len(lst) // 2
    while move > 0:
        for i in range(len(lst) - move):
            if lst[i] > lst[i+move]:
                lst[i], lst[i+move] = lst[i+move], lst[i]
        move //= 2
    return lst

### Сортировка Хоара. Здесь мы берем случайный элемент из списка и формируем два списка, ставя вокруг данного элемента. Способ рекурсивный.
def quick_sort(lst):
    if len(lst) > 1:
        x = matrix[random.randint(0, len(lst)-1)]
        low = [l for l in matrix if l < x]
        eq = [l for l in matrix if l == x]
        high = [l for l in matrix if l > x]
        lst = quick_sort(low) + eq + quick_sort(high)
    return lst

### Сортировка слиянием. Делим исходный наш лист постоянно на две части, пока каждый элемент не будет по отдельности. Объединяем листы, а потом сортируем с помощью сортировки выбора (def merge_list).

def merge_sort(lst : list) -> list:
    def merge_list(a, b):
        sum_list, c = a + b, []
        while sum_list:
            c.append(sum_list.pop(sum_list.index(min(sum_list))))
        return c
    def split_and_merge_list(lst):
        a, b = lst[len(lst) // 2:], lst[:len(lst) // 2]
        if len(a) > 1:
            a = split_and_merge_list(a)
        if len(b) > 1:
            b = split_and_merge_list(b)
        return merge_list(a, b)
    return split_and_merge_list(lst)

###Сортировка кучей с помощью модуля heapq.
def heap_sort(list_for_sort: list) -> list:
    heapq.heapify(list_for_sort)
    return [heapq.heappop(list_for_sort) for i in range(len(list_for_sort))]

###Сортировка кучей без модуля. Все действия описаны в процессе кода.

def heap_sort(numbers):
    ### n - кол-во элементов
    def heapify(numbers : list, indexs : int, n : int) -> list:
        l_child, r_child = 2*indexs + 1, 2*indexs + 2 #дочерние элементы
        root_element = indexs #препдполагаем, что наш корневой элемент максимальный

        #проверяем, что мы не вылетели из списка по длине, поиск старшего элемента, max() неправильно
        if l_child <= n and numbers[l_child] > numbers[root_element]:
            root_element = l_child

        if r_child <= n and numbers[r_child] > numbers[root_element]:
            root_element = r_child
        #Если элемент не поменялся, то прекращаем работу функции
        if root_element == indexs:
            return numbers
        else:
            numbers[root_element], numbers[indexs] = numbers[indexs], numbers[root_element]
            #Продолжаем проверять для каждого старшего элемента
            heapify(numbers, root_element, n)

    def build_max_heap(numbers : list) -> list:
        #Алгоритм сам по себе работает с центра, то есть это первые действие в нашей сортировке.
        #Вызываем от центрального и ссылаемся на прошлую функцию с действиями.
        index_middle = len(numbers) // 2
        for idx in range(index_middle, -1, -1):
            heapify(numbers, idx, len(numbers) - 1)

    def last_sort(numbers: list) -> list:
        #Восстанваливаем св-ва пирамиды со старта
        build_max_heap(numbers)
        for idx in range(len(numbers) - 1, -1, -1):
            numbers[0], numbers[idx] = numbers[idx], numbers[0]
            heapify(numbers, 0, idx - 1)

        return numbers

    return last_sort(numbers)

### Сортировка по столбцам матрицы. Если нужно сортировать столбец матрицы, то можно использовать numpy. m - количество столбцов матрицы, mas - вложенный двумерный список.
import numpy as np

def colum_matrix_sort(mas):
    mas = np.array(mas)
    m = len(mas[1:,])
    for k in range(m):
        mas[:, k] = sorted(mas[:, k])
        return np.around(mas, decimals=3)