Сортировка слиянием
Сортировка слияния разделена и завоевать алгоритм. Он делит входной массив на две половинки, называет себя для двух половинок, а затем объединяет две сортированные половинки. Функция Merge () используется для объединения двух половинок. Merge (ARR, L, M, R) является ключевым процессом, который предполагает, что ARR [L..m] и ARR [M + L .. R] отсортированы и объединяет две сортированные подпрограммы в один.
def mergeSort(arr):
if len(arr) > 1:
mid = len(arr)
L = arr[:mid]
R = arr[mid:]
mergeSort(L)
mergeSort(R)
i = j = k = 0
while i < len(L) and j < len(R):
if L[i] < R[j]:
arr[k] = L[i]
i += 1
else:
arr[k] = R[j]
j += 1
k += 1
while i < len(L):
arr[k] = L[i]
i += 1
k += 1
while i < len(R):
arr[k] = R[j]
j += 1
k += 1
def printList(arr):
for i in range(len(arr)):
print(arr[i], end=" ")
print()
if __name__ == '__main__':
arr = [12, 11, 13, 5, 6, 7]
print("Given array is", end="\n")
printList(arr)
mergeSort(arr)
print("Sorted array is", end="\n")
printList(arr)
# Output
Given array is
12 11 13 5 6 7
Sorted array is
5 6 7 11 12 13
Функция ниже рекурсивной, следовательно, он использует стек вызова функции для хранения промежуточных значений L и H. Стек Call Call хранит другую информацию о бухгалтерском языке вместе с параметрами. Кроме того, функционные вызовы включают в себя накладные расходы, такие как смазка для активации функции вызывающего абонента, а затем возобновление выполнения.
def merge(left, right):
if not len(left) or not len(right):
return left or right
result = []
i,j = 0,0
while (len(result) < len(left) + len(right)):
if left[i] < right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
if i == len(left) or j == len(right):
result.extend(left[i:] or right[j:])
break
return result
def mergesort(list):
if len(list) < 2:
return list
middle = len(list)/2
left = mergesort(list[:middle])
right = mergesort(list[middle:])
return merge(left, right)
seq = (12, 11, 13, 5, 6, 7)
print("Given array is")
print(seq)
print("\n")
print("Sorted array is")
print(mergesort(seq))
# Output
Given array is
12 11 13 5 6 7
Sorted array is
5 6 7 11 12 13
В отличие от Iterative Quick Sort, интерактивный сорт слияния не требует явного вспомогательного стека.
def mergeSort(a):
current_size = 1
while current_size < len(a) - 1:
left = 0
while left < len(a) - 1:
mid = left + current_size - 1
right = ((2 * current_size + left - 1,
len(a) - 1) [2 * current_size + left - 1 > len(a) - 1])
merge(a, left, mid, right)
left = left + current_size * 2
current_size = 2 * current_size
def merge(a, l, m, r):
n1 = m - l + 1
n2 = r - m
L = [0] * n1
R = [0] * n2
for i in range(0, n1):
L[i] = a[l + i]
for i in range(0, n2):
R[i] = a[m + i + 1]
i, j, k = 0, 0, l
while i < n1 and j < n2:
if L[i] > R[j]:
a[k] = R[j]
j += 1
else:
a[k] = L[i]
i += 1
k += 1
while i < n1:
a[k] = L[i]
i += 1
k += 1
while j < n2:
a[k] = R[j]
j += 1
k += 1
a = [12, 11, 13, 5, 6, 7]
print("Given array is")
print(a)
mergeSort(a)
print("Sorted array is")
print(a)
# Output
Given array is
12 11 13 5 6 7
Sorted array is
5 6 7 11 12 13
Heapsort.
Heapsort – это метод сортировки на основе сравнения, основанную на структуре данных двоичной кучи. Это похоже на сорт выбора, где сначала найдите максимальный элемент и поместите максимальный элемент в конце.
Что такое двоичная куча? Двоичная куча – это структура данных кучи, которая принимает форму бинарного дерева. Двоичные кучи – это обычный способ внедрения Очереди приоритетов Отказ
Двоичная куча определяется как двоичное дерево с двумя дополнительными ограничениями:
- Свойство формы: двоичная куча – это полное двоичное дерево; То есть все уровни дерева, за исключением, возможно, последний (самый глубокий), полностью заполнены, и, если последний уровень дерева не завершен, узлы этого уровня заполняются слева направо.
- Свойство кучи: ключ, хранящийся в каждом узле, либо больше или равно (≥) или меньше или равно (≤) клавишах в детях узла, согласно некоторому общему порядку.
Кучи, где родительский ключ больше или равен (≥) клавиши дочерних клавиш, называются макс-кучами; те, где он меньше или равен (≤), называются мин-кучами. (Подробнее на Википедии))
Почему представление на основе массива для двоичной кучи? Поскольку двоичная куча представляет собой полное бинарное дерево, его можно легко представить в виде массива и представление на основе массива пространство эффективно. Если родительский узел хранится при индексе 1, левый ребенок может быть рассчитан на 2 * I + 1 и правый ребенок на 2 * I * 2.
Алгоритм сортировки кучи для сортировки в увеличении порядка:
- Создайте максимальную кучу от входных данных.
- Наибольший элемент хранится в корне кучи. Замените его последним элементом кучи, а затем снижение размера кучи на 1. После этого вздрогнул корень дерева.
- Повторите вышеуказанные шаги, пока размер кучи превышает 1.
def heapify(arr,n,i):
largest = i
l = 2*i+1
r = 2*i+2
if l < n and arr[i] < arr[l]:
largest = l
if r < n and arr[largest] < arr[r]:
largest = r
if largest != i:
arr[i],arr[largest] = arr[largest],arr[i]
heapify(arr,n,largest)
def heapSort(arr):
n = len(arr)
for i in range(n,-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)
arr = [12, 11, 13, 5, 6, 7]
heapSort(arr)
n = len(arr)
print("Sorted array is")
for i in range(n):
print("%d" %arr[i])
# Output
Sorted array is
5 6 7 11 12 13
Сортировка сортировки
Сортировка подсчета – это метод сортировки на основе ключей между определенным диапазоном. Он работает, считая количество объектов, имеющих различные ключевые значения. Затем выполняя артметику для расчета положения каждого объекта в выходной последовательности.
def countSort(arr):
output = [0 for i in range(256)]
count = [0 for i in range(256)]
ans = ["" for _ in arr]
for i in arr:
count[ord(i)] += 1
for i in range(256):
count[i] += count[i-1]
for i in range(len(arr)):
output[count[ord(arr[i])] -1] = arr[i]
count[ord(arr[i])] -= 1
for i in range(len(arr)):
ans[i] = output[i]
return ans
arr = "Yogeswaran"
ans = countSort(arr)
print("Sorted character array is %s" %("".join(ans)))
# Output
Sorted character array is Yaaegnorsw
Radix Sort.
Radix Сортировка – не сравнительный алгоритм целочисленного сортировки, который сортирует данные с целочисленными клавишами путем группировки ключей отдельных цифр, которые имеют одинаковую значительную позицию и значение. Требуется позиционировочная запись, но поскольку целые числа могут представлять строки символов (например, имена или даты) и специально отформатированные номера плавающих точек, Radix Sort не ограничивается целыми числами. (Источник Википедия)
Вы можете проверить пример алгоритма сортировки Radix здесь
Сортировка ведра
Сортировка ведра в основном полезен, когда вход равномерно распределен по диапазону.
def insertionSort(b):
for i in range(1, len(b)):
up = b[i]
j = i - 1
while j >= 0 and b[j] > up:
b[j+1] = b[j]
j -= 1
b[j+1] = up
return b
def bucketSort(x):
arr = []
slot_num = 10
for i in range(slot_num):
arr.append([])
for j in x:
index_b = int(slot_num * j)
arr[i] = insertionSort(arr[i])
k = 0
for i in range(slot_num):
for j in range(len(arr[i])):
x[k] = arr[i][j]
k += 1
return x
x = [0.897, 0.565, 0.656,
0.1234, 0.665, 0.3434]
print("Sorted array is")
print(bucketSort(x))
# Output
Sorted array is
0.1234 0.3434 0.565 0.656 0.665 0.897
Shellsort.
Shellsort, также известный как метод сортировки оболочки или Shell, является сортетом сравнения в месте. Его можно рассматривать как обобщение сортировки по обмену (Bubble Sort) или сортировку путем вставки (сортировка вставки). Метод начинается, сортируя пары элементов далеко друг от друга, затем постепенно снижают разрыв между элементами. Начиная с далеко друг от друга элементами, он может перемещать некоторые из-за места в положение быстрее, чем простой ближайший обмен сосед. (Источник: Википедия)
def shellSort(arr):
n = len(arr)
gap = n
while gap > 0:
for i in range(gap,n):
temp = arr[i]
j = i
while j >= gap and arr[j-gap] > temp:
arr[j] = arr[j-gap]
j -= gap
arr[j] = temp
gap
arr = [12, 34, 54, 2, 3]
n = len(arr)
print("Array before sorting")
for i in range(n):
print(arr[i])
shellSort(arr)
print("\nArray after sorting")
for i in range(n):
print(arr[i])
# Output
Array before sorting
12 34 54 2 3
Array after sorting
2 3 12 34 54
Timsort.
Timsort – это гибридный стабильный алгоритм сортировки, полученный из сортировки слияния и вставки, предназначенные для успеваемости на многих видах реальных данных.
- Стабильный алгоритм сортировки работает в O (NLONGE).
- Используется в Java массива .sort (), а также сортировка Python () и сортировка ().
- Сначала сортируйте небольшие кусочки с помощью вставки сортировки, а затем объединяет кусочки с использованием слияния сортировки слияния.
RUN = 32
def insertionSort(arr, left, right):
for i in range(left + 1, right+1):
temp = arr[i]
j = i - 1
while arr[j] > temp and j >= left:
arr[j+1] = arr[j]
j -= 1
arr[j+1] = temp
def merge(arr, l, m, r):
len1, len2 = m - l + 1, r - m
left, right = [], []
for i in range(0, len1):
left.append(arr[l + i])
for i in range(0, len2):
right.append(arr[m + 1 + i])
i, j, k = 0, 0, l
while i < len1 and j < len2:
if left[i] <= right[j]:
arr[k] = left[i]
i += 1
else:
arr[k] = right[j]
j += 1
k += 1
while i < len1:
arr[k] = left[i]
k += 1
i += 1
while j < len2:
arr[k] = right[j]
k += 1
j += 1
def timSort(arr, n):
for i in range(0, n, RUN):
insertionSort(arr, i, min((i+31), (n-1)))
size = RUN
while size < n:
for left in range(0, n, 2*size):
mid = left + size - 1
right = min((left + 2*size - 1), (n-1))
merge(arr, left, mid, right)
size = 2*size
def printArray(arr, n):
for i in range(0, n):
print(arr[i], end = " ")
print()
if __name__ == "__main__":
arr = [5, 21, 7, 23, 19]
n = len(arr)
print("Given array is")
printArray(arr, n)
timSort(arr, n)
print("After sorting array is")
printArray(arr, n)
# Output
Given array is
5 21 7 23 19
After sorting array is
5 7 19 21 23
Присоединяйтесь к моему Сообщество
Оригинал: “https://dev.to/yogeswaran79/part-2-sorting-algorithm-17p5”