https://www.cnblogs.com/onepixel/p/7674659.html This article is nice

https://www.bilibili.com/video/av685670?from=search&seid=1637373535603658338 This motion picture is excellent

https://www.icourse163.org/course/ZJU-93001 MOOC Zhejiang Big Data Structure Chen Yue and He Qin-ming

Bubble sort, select sort, insert sort are the three slowest and most classic sort algorithms

Quick sorting is generally believed to be the fastest known sorting for large random number columns

## bubble sort

The simplest sorting algorithm is also the least efficient because it must swap before the final location is known, wasting many "swap operations"

If the list is sorted, it is best if no swap is needed during traversal, and if sorted, it can be terminated earlier. Bubbles under this modification are often referred to as short bubble sorting

Time Complexity: Average O(n^2), Worst O(n^2), Best O(n)

Spatial Complexity: O(1)

Stable

#Test input array alist = [27, 33, 28, 4, 2, 26, 13, 35, 8, 14] #Bubble sort for i in range(len(alist)-1): for j in range(len(alist)-1-i): if alist[j] > alist[j+1]: alist[j],alist[j+1] = alist[j+1],alist[j] #Sort results output print('sorted:',alist)

## Select Sort selection sort

Selective sorting improves bubble sorting by only exchanging once per iteration of the list

Time Complexity: Average O(n^2), Worst O(n^2), Best O(n^2)

Spatial Complexity: O(1)

Instable

#Test input array alist = [27, 33, 28, 4, 2, 26, 13, 35, 8, 14] #Select Sort for i in range(len(alist)-1): least = i for j in range(i+1,len(alist)): if alist[j] < alist[least]: least = j if least != i: alist[least],alist[i] = alist[i],alist[least] #Sort results output print('sorted:',alist)

## Insert sort insertion sort

It always maintains a sorted sublist at the lower position of the list, then "inserts" each new item back to the previous sublist, making the sorted sublist a larger item

Time Complexity: Average O(n^2), Worst O(n^2), Best O(n)

Spatial Complexity: O(1)

Stable

#Test input array alist = [27, 33, 28, 4, 2, 26, 13, 35, 8, 14] #Insert Sort for i in range(1,len(alist)): j = i; while j>0 and alist[j-1]>alist[j]: alist[j-1],alist[j] = alist[j],alist[j-1] j -= 1 #Sort results output print('sorted:',alist)

## Hill sort shell

It was invented by Shell in 1959. The first breakthrough in O(n^2) sorting is an improvement on simple insert sorting. Unlike insert sorting, it gives priority to elements that are farther apart, also known as "descending incremental sorting"

It is an improvement on the following two features of insert sorting: efficient operation on data that is almost sorted to achieve the efficiency of linear sorting; generally inefficient because insert sorting can only move data one bit at a time

Hill sorting improves the performance of insert sorting by dividing all elements of the comparison into zones.This allows an element to make a big step forward toward its final position at once

Gap concept, gap decreases, the last step is to insert sort, but it's almost in order now

gap is the Hill sorting core

The well-known gap set Marcin Ciura's gap sequence, gap s = [701, 301, 132, 57, 23, 10, 4, 1], but the following example uses a sequence whose array length is continuously divided by 2 as a gap s

Time Complexity: Average O(n(logn)^2), Worst O(n^2), Best O(n)

Spatial Complexity: O(1)

Instable

#Test input array alist = [27, 33, 28, 4, 2, 26, 13, 35, 8, 14] #Shell Sort gap = len(alist)//2 while gap>0: #Sort each gap by insertion for i in range(gap,len(alist)): j = i while j>=gap and alist[j-gap]>alist[j]: alist[j-gap],alist[j] = alist[j],alist[j-gap] j -= gap gap = gap//2 #Sort results output print('sorted:',alist)

## merge sort

The divide-and-conquer strategy to improve performance is a typical application of divide-and-conquer

Merge Sort is a recursive algorithm that constantly splits lists into half

Two-way merge and multiple merge

The disadvantage is that the merge process requires additional storage space

Time Complexity: Average O(nlogn), Worst O(nlogn), Best O(nlogn)

Spatial Complexity: O(n)

Stable

#Test input array alist = [27, 33, 28, 4, 2, 26, 13, 35, 8, 14] #Merge Sort def merge_sort(ilist): def merge(left, right): result = [] while left and right: result.append((left if left[0] <= right[0] else right).pop(0)) return result + left + right if len(ilist) <= 1: return ilist mid = len(ilist) // 2 return merge(merge_sort(ilist[:mid]), merge_sort(ilist[mid:])) #Sort results output print('sorted:',merge_sort(alist))

## quick sort

Same as merge sort, divide and conquer without extra storage

Is an improvement on bubble sorting

Usually significantly faster than other algorithms because its internal loops can be efficiently accomplished on most architectures

Simple versions are just as bad as merge sort and require extra storage, but you can change to in-place without extra space

Time Complexity: Average O(nlogn), Worst O(n^2), Best O(nlogn)

Spatial Complexity: O(nlogn)

Instable

#Test input array alist = [27, 33, 28, 4, 2, 26, 13, 35, 8, 14] #Quick Sort def quick_sort(ilist): length = len(ilist) if length <= 1: return ilist else: # Use the last element as the first pivot pivot = ilist.pop() # Put elements greater than pivot in greater list # Put elements lesser than pivot in lesser list greater, lesser = [], [] for element in ilist: if element > pivot: greater.append(element) else: lesser.append(element) return quick_sort(lesser) + [pivot] + quick_sort(greater) #Sort results output print('sorted:',quick_sort(alist))

## heap sort

Is an improvement on selection ordering

The algorithm designed with heap data structure approximates a complete binary tree

A heap usually solves a large root heap or a small root heap through a one-dimensional array

Time Complexity: Average O(nlogn), Worst O(nlogn), Best O(nlogn)

Spatial Complexity: O(1)

Instable

#Test input array alist = [27, 33, 28, 4, 2, 26, 13, 35, 8, 14] #Heap Sorting def heapify(unsorted, index, heap_size): largest = index left_index = 2 * index + 1 right_index = 2 * index + 2 if left_index < heap_size and unsorted[left_index] > unsorted[largest]: largest = left_index if right_index < heap_size and unsorted[right_index] > unsorted[largest]: largest = right_index if largest != index: unsorted[largest], unsorted[index] = unsorted[index], unsorted[largest] heapify(unsorted, largest, heap_size) def heap_sort(unsorted): n = len(unsorted) for i in range(n // 2 - 1, -1, -1): heapify(unsorted, i, n) for i in range(n - 1, 0, -1): unsorted[0], unsorted[i] = unsorted[i], unsorted[0] heapify(unsorted, 0, i) return unsorted #Sort results output print('sorted:',heap_sort(alist))