На каждом этапе реализации мы проведем вас через различные алгоритмы сортировки. Python будет компонентом реализации. Когда у вас есть алгоритм, вы можете быстро интегрировать его в любой язык. Это тема синтаксиса языка. Окунитесь в алгоритмы сортировки.

Понимание реализации связанных списков в Python

Вставка сортировки

Один из самых простых алгоритмов сортировки - это тип вставки. Реализация проста. И вам придется дополнительно разобрать массив. В большинстве случаев он не используется для сортировки больших массивов. Метод вставки сохраняет отсортированные части в предоставленной таблице. В начале процесса сортировки подчасть сортировки включает только первый элемент. В отсортированном подмассиве мы выбираем элемент из несортированного массива и вставляем его в нужное место. Временная сложность составляет O (n2), а пространственная сложность - O (1).

def insertion_sort(arr, n):
	for i in range(1, n):
		current_position = i
		current_element = arr[i]
		while current_position > 0 and current_element <
		 arr[current_position - 1]:

			arr[current_position] = arr[current_position - 1]
			current_position -= 1
		arr[current_position] = current_element
if __name__ == '__main__':
	arr = [2, 3, 6, 7, 8, 9, 1, 4, 5]
	insertion_sort(arr, 9)
	print(str(arr))

Сортировка выделения похожа на вставку с небольшим изменением. Он также разделяет массив на классифицированные и несортированные компоненты. Затем мы выбираем наименьший элемент из каждой итерации из несортированного подраздела и вставляем его в последнюю позицию в отсортированном подразделе. Временная сложность составляет O (n2), а пространственная сложность - O (1).

def selection_sort(arr, n):
	for i in range(n):
		min_element_index = i
		for j in range(i + 1, n):
			if arr[j] < arr[min_element_index]:
				min_element_index = j
		arr[i], arr[min_element_index] = arr[min_element_index], arr[i]
if __name__ == '__main__':
	arr = [2, 3, 6, 7, 8, 9, 1, 4, 5]
	selection_sort(arr, 9)
	print(str(arr))

Сортировка пузырьков - это простой алгоритм. Он постоянно меняет местами соседние записи на каждой итерации, пока интересующий массив не будет отсортирован. Он проходит по панели и перемещает текущий элемент на следующее место, пока не станет ниже следующего. Временная сложность O (n2) и пространственная сложность O (1).

def bubble_sort(arr, n):
	for i in range(n):
		for j in range(n - i - 1):
			if arr[j] > arr[j + 1]:
				arr[j], arr[j + 1] = arr[j + 1], arr[j]
if __name__ == '__main__':
	arr = [2, 3, 6, 7, 8, 9, 1, 4, 5]
	bubble_sort(arr, 9)
	print(str(arr))

Сортировка слиянием - это рекурсивный алгоритм сортировки массивов. С точки зрения временной сложности он более эффективен, чем ранее представленные алгоритмы. Он следует подходу разделения и завоевания. Алгоритм сортировки слиянием разбивает массив на две части по отдельности. После сортировки он объединяет две половины в один отсортированный массив. Он разбивает массив до тех пор, пока он не станет самой простой сортировкой. Поскольку это рекурсивный алгоритм. Временная сложность составляет O (nlogn), а пространственная сложность - O (1).

def merge(arr, left_index, mid_index, right_index):
	left_array = arr[left_index:mid_index+1]
	right_array = arr[mid_index+1:right_index+1]
	left_array_length = mid_index - left_index + 1
	right_array_length = right_index - mid_index
	i = j = 0
	k = left_index
	while i < left_array_length and j < right_array_length:
		if left_array[i] < right_array[j]:
			arr[k] = left_array[i]
			i += 1
		else:
			arr[k] = right_array[j]
			j += 1
		k += 1
	while i < left_array_length:
		arr[k] = left_array[i]
		i += 1
		k += 1
	while j < right_array_length:
		j += 1
		k += 1
def merge_sort(arr, left_index, right_index):
	if left_index >= right_index:
		return
	mid_index = (left_index + right_index) 
	merge_sort(arr, left_index, mid_index)
	merge_sort(arr, mid_index + 1, right_index)
	merge(arr, left_index, mid_index, right_index)
if __name__ == '__main__':
	arr = [2, 3, 6, 7, 8, 9, 1, 4, 5]
	merge_sort(arr, 0, 8)
	print(str(arr))