└── README.md


/README.md:
--------------------------------------------------------------------------------
  1 | # Алгоритмы сортировки на Python
  2 | 
  3 | ## Сортировка пузырьком (Bubble Sort)
  4 | Сортировка пузырьком проходит по массиву несколько раз. На каждом этапе алгоритм сравнивает два соседних элемента и, если левый элемент больше правого — меняет их местами. Такой проход гарантирует что самое больше число будет в конце массива. Этот процесс попарного сравнения повторяется до тех пор, пока каждый элемент не будет на своем месте.
  5 | 
  6 | ```python
  7 | def bubble_sort(arr):
  8 |     n = len(arr)
  9 |     for i in range(n):
 10 |         for j in range(n-i-1):
 11 |             if arr[j] > arr[j+1]:
 12 |                 arr[j], arr[j+1] = arr[j+1], arr[j]
 13 |     return arr
 14 | ```
 15 | 
 16 | Оценка сложности:
 17 | - В худшем случае **O(n)**
 18 | - В среднем случае **O(n²)**
 19 | - В лучшем случае **O(n²)**
 20 | 
 21 | ## Сортировка выбором (Selection Sort)
 22 | Основная идея — рассматривать последовательность как две части: первая включает отсортированные элементы, вторая — неотсортированные. Алгоритм находит наименьшее число из неотсортированной части и помещает его в конец отсортированной.
 23 | 
 24 | ```python
 25 | def selection_sort(arr):
 26 |     n = len(arr)
 27 |     for i in range(n-1):
 28 |         min_index = i
 29 |         for j in range(i+1, n):
 30 |             if arr[j] < arr[min_index]:
 31 |                 min_index = j
 32 |         if min_index != i:
 33 |             arr[i], arr[min_index] = arr[min_index], arr[i]
 34 |     return arr
 35 | ```
 36 | 
 37 | Оценка сложности:
 38 | - В худшем случае **O(n)**
 39 | - В среднем случае **O(n²)**
 40 | - В лучшем случае **O(n²)**
 41 | 
 42 | ## Сортировка вставками (Insertion Sort)
 43 | Этот алгоритм совмещает идеи первых двух алгоритмов. Как и в сортировке выбором представляем последовательность как две части: первая включает отсортированные элменты, вторая — неотсортированные. Алгоритм сортировки вставками последовательно помещает каждый элемент из неотсортированной части на правильную позицию отсортированной части.
 44 | 
 45 | ```python
 46 | def insertion_sort(arr):
 47 |     n = len(arr)
 48 |     for i in range(1, n):
 49 |         current_value = arr[i]
 50 |         j = i - 1
 51 |         while j >= 0:
 52 |             if current_value < arr[j]:
 53 |                 arr[j+1] = arr[j]
 54 |                 arr[j] = current_value
 55 |                 j = j - 1
 56 |             else:
 57 |                 break
 58 |     return arr
 59 | ```
 60 | 
 61 | Оценка сложности:
 62 | - В худшем случае **O(N²)**
 63 | - В среднем случае **O(N²)**
 64 | - В лучшем случае **O(N²)**
 65 | 
 66 | ## Быстрая сортировка  (Quick Sort)
 67 | Рекурсивный алгоритм, который работает по следующему принципу:
 68 | 1. Выбрать опорный элемент из массива. Это можно сделать разными способами, в данной реализации этой будет случайный элемент.
 69 | 2. Сравнить все элементы с опорным и распределить их в подмассивы. Первый подмассив будет состоять из элементов, которые меньше опорного; второй — больше опорного или равные.
 70 | 3. Рекурсивно выполнить шаги 1 и 2, пока в подмассиве есть хотя бы 2 элемента.
 71 | 
 72 | ```python
 73 | import random
 74 | 
 75 | def quick_sort(arr):
 76 |     n = len(arr)
 77 |     if n <= 1:
 78 |         return arr
 79 |     else:
 80 |         pivot = random.choice(arr)
 81 |         less = [x for x in arr if x < pivot]
 82 |         greater_or_equal = [x for x in arr if x >= pivot]
 83 |         return quick_sort(less) + quick_sort(greater_or_equal)
 84 | ```
 85 | 
 86 | Оценка сложности:
 87 | - В худшем случае **O(n²)**
 88 | - В среднем случае **O(n * log n)**
 89 | - В лучшем случае **O(n * log n)**
 90 | 
 91 | ## Сортировка слиянием (Merge Sort)
 92 | Рекурсивный алгоритм, который работает по следующему принципу:
 93 | 1. Разделить массив на две равные части
 94 | 2. Отсортировать каждую половину
 95 | 3. Из двух отсортированных массивов получить один (операция слияния)
 96 | 
 97 | ```python
 98 | def merge_sort(arr):
 99 |     n = len(arr)
100 |     if n <= 1:
101 |         return arr
102 |     else:
103 |         middle = int(len(arr) / 2)
104 |         left = merge_sort(arr[:middle])
105 |         right = merge_sort(arr[middle:])
106 |         return merge(left, right)
107 | 
108 | def merge(left, right):
109 |     result = []
110 |     while len(left) > 0 and len(right) > 0:
111 |         if left[0] <= right[0]:
112 |             result.append(left[0])
113 |             left = left[1:]
114 |         else:
115 |             result.append(right[0])
116 |             right = right[1:]
117 |     if len(left) > 0:
118 |         result += left
119 |     if len(right) > 0:
120 |         result += right
121 |     return result
122 | ```
123 | 
124 | Оценка сложности:
125 | - В худшем случае **O(n * log n)**
126 | - В среднем случае **O(n * log n)**
127 | - В лучшем случае **O(n * log n)**
128 | 


--------------------------------------------------------------------------------