Write in front
Sorting is the two most important concepts in search algorithm. We are searching and sorting in most cases. Scientists have made every effort to make sorting and searching faster. This article uses Python to implement the top ten sorting algorithms.
Dry goods
Sorting algorithms can be divided into many categories from different dimensions. From their sorting ideas (which generally determine the magnitude of their time complexity), they can be divided into four categories:
 Double level cyclic comparison sort: square sort
 Divide and conquer strategy comparison sort: logarithmic sort
 Alternative non comparative sorting: linear sorting
 Other orders of laughing dead people do not pay for their lives: it is difficult to describe the time complexity.
Square sort

Bubble sorting
 Starting from the first element of the array, compare the current element with the next element. If the current element is greater than the next element, exchange the positions of the two elements.
 Then, starting with the second element, repeat the first step until the current element is the last element. At this point, the last element is the largest element. An unordered array is an element other than the last element.
 Repeat the above steps for the unordered array until the unordered array is empty.
def bubble_sort(arr): length = len(arr) for i in range(length): for j in range(lengthi1): if arr[j] > arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j] return arr

Select sort
 Select the smallest element in the array and exchange positions with the first element in the array
 Select the smallest element of the remaining elements in the array except the first element, and exchange positions with the second element in the array.
 Repeat the above steps until the currently selected element is the last element in the array.
def select_sort(arr): length = len(arr) for i in range(length): min_ix = i for j in range(i, length): if arr[j] < arr[min_ix]: min_ix = j arr[min_ix], arr[i] = arr[i], arr[min_ix] return arr

Insert sort
 Starting with the first element of the array, constantly compare the current element with the previous element. If the current element is smaller than the previous element, the current element is inserted in front of the previous element (that is, the two exchange positions)
 Starting with the second element, repeat the above steps until all elements go through the above steps.
def insert_sort(arr): length = len(arr) for i in range(length): for j in range(i, 0, 1): if arr[j] < arr[j1]: arr[j], arr[j1] = arr[j1], arr[j] return arr
Logarithmic order

Shell Sort
 Select an incremental value K to place the elements with K as the interval index in the array in the same array.
 Reduce the increment value to 1 / 2 of the original increment value, and then repeat step 1.
 Until the increment value is 1, use insert sort to sort the partially ordered array.
def shell_sort(arr): n = len(arr) gap = int(n/2) while gap > 0: for i in range(gap,n): temp = arr[i] j = i while j >= gap and arr[jgap] >temp: arr[j] = arr[jgap] j = gap arr[j] = temp gap = int(gap/2) return arr

Merge sort
 Taking the middle elements of the array as the boundary, the array is divided into two arrays of equal length (may not be equal in length, which is related to the parity of the array length).
 Perform step 1 for all arrays
 Repeat the above steps until the array is divided into multiple arrays containing a single element.
 Merge the above arrays in pairs and sort them. At this time, there are multiple arrays containing ordered two elements (may contain a single element, which is related to the parity of the array length).
 Repeat step 4 until all arrays are merged into one array
def merge(left, right): i = j = 0 res = [] while i < len(left) and j < len(right): if left[i] < right[j]: res.append(left[i]) i += 1 else: res.append(right[j]) j += 1 if i == len(left): res.extend(right[j:]) else: res.extend(left[i:]) return res def merge_sort(arr): if len(arr) <= 1: return arr length = len(arr) i = int(length / 2) left = merge_sort(arr[:i]) right = merge_sort(arr[i:]) return merge(left, right)

Quick sort
 Select an element as the benchmark
 Elements larger than the benchmark are used as an array, and elements smaller than or equal to the benchmark are used as an array.
 Repeat the above steps for the newly segmented array until the segmented array contains only 1 or 0 elements
 Recursively merge the above arrays into ordered arrays by: [elements less than or equal to the benchmark] + [benchmark] + [elements greater than the benchmark]
def fast_sort(arr): if len(arr) <= 1: return arr pivot = arr.pop() left = [i for i in arr if i <= pivot] right = [i for i in arr if i > pivot] return fast_sort(left) + [pivot] + fast_sort(right)
The above algorithm requires additional space. If we continuously place elements less than or equal to the benchmark before the benchmark element and elements greater than the benchmark after the benchmark element, we can realize insitu sorting without additional space.
def fast_sort_on_extra_spacing(arr): l = 0 h = len(arr)1 def partition(arr, l, h): pivot = arr[h] for i in range(l, h): if arr[i] <= pivot: arr[l], arr[i] = arr[i], arr[l] l += 1 arr[h], arr[l] = arr[l], arr[h] return l def fast_sort(arr, l, h): if l < h: pivot = partition(arr, l, h) fast_sort(arr, l, pivot1) fast_sort(arr, pivot+1, h) return arr return fast_sort(arr, l, h)

Heap sort
 First, construct a large root heap for the array to be sorted
 Swap the first and last elements of the large root heap. At this time, the last element is the largest element, and the array to be sorted is all elements except the last element.
 Repeat the above steps for the array to be sorted until there is only one element in the array to be sorted.
def heapify(arr, n, i): # build a max root heap max_ix = i left_i = 2 * i + 1 right_i = 2 * i + 2 if left_i < n and arr[max_ix] < arr[left_i]: max_ix = left_i if right_i < n and arr[max_ix] < arr[right_i]: max_ix = right_i if max_ix != i: arr[max_ix], arr[i] = arr[i], arr[max_ix] heapify(arr, n, max_ix) def heap_sort(arr): for i in range(n1, 1, 1): heapify(arr, n, i) for i in range(n1, 0, 1): arr[i], arr[0] = arr[0], arr[i] heapify(arr, i, 0) return arr
Linear ranking
This sorting method is only applicable to the case where the array elements are all integers.

Count sort
 Find the largest element in the array to be sorted and construct a count array with a length of this element value.
 Traverse the array elements to be sorted, take the current element as the index, and add the corresponding value in the count array by 1
 At this time, the index in the count array is the element in the array to be sorted, and the value is the number of occurrences. Concatenate the indexes of all elements with nonzero values in the count array according to their occurrence times.
def count_sort(arr): min_ix, max_ix = min(arr), max(arr) bucket = [0 for _ in range(max_ix+1)] for i in arr: bucket[i] += 1 return sum([[i] * bucket[i] for i in range(len(bucket)) if bucket[i] != 0], [])

Bucket sorting
 Set a fixed number of buckets (this is a technical job)
 Put the elements in the array to be sorted into the corresponding bucket (the correspondence is also a technical work, and the following example uses integer division)
 Concatenate the elements in a non empty bucket.
def bucket_sort(arr): min_ix, max_ix = min(arr), max(arr) bucket_range = (max_ix  min_ix) / len(arr) # +1 avoid for that max_ix  min_ix will raise a IndexError temp_bucket = [[] for i in range(len(arr) + 1)] for i in arr: temp_bucket[int((imin_ix)//bucket_range)].append(i) return sum(temp_bucket, [])

Cardinality sort
 Find the number of bits of the largest element in the array to be sorted. Make up this number of digits for all elements by filling 0 in front.
 Multiple rounds of array sorting are performed from the lowest to the highest.
def radix_sort(arr): max_value = max(arr) num_digits = len(str(max_value)) for i in range(num_digits): bucket = [[] for _ in range(10)] for j in arr: bucket[j//(10**i)%10].append(j) arr = [j for i in bucket for j in i] return arr
Laughing is not worth your life

Sleep sorting
Let multiple processes (threads) sleep the elements in the array to be sorted for a long time. For the process (thread) that wakes up first, the corresponding elements are appended to the result array.

Monkey sorting
Keep sorting randomly, and then check whether all elements are in order. If you are European emperor, you can try this sorting algorithm, which is likely to be done at one time.
Summary of complexity, stability and generality of sorting algorithm
algorithm  Average time complexity  Optimal time complexity  Worst time complexity  Spatial complexity  Sort in place  Is it stable  Is it universal 

Bubble sorting  O(n^{2})  O(n)  O(n^{2})  O(1)  yes  yes  yes 
Select sort  O(n^{2})  O(n^{2})  O(n^{2})  O(1)  yes  no  yes 
Insert sort  O(n^{2})  O(n)  O(n^{2})  O(1)  yes  yes  yes 
Shell Sort  O(n logn)  O(n log^{2}n)  O(n log^{2}n)  O(1)  yes  no  yes 
Merge sort  O(n logn)  O(n logn)  O(n logn)  O(n)  no  yes  yes 
Quick sort  O(n logn)  O(n logn)  O(n^{2})  O(n logn)  yes  no  yes 
Heap sort  O(n logn)  O(n logn)  O(n logn)  O(1)  yes  no  yes 
Count sort  O(n+k)  O(n+k)  O(n+k)  O(k)  no  yes  no 
Bucket sorting  O(n+k)  O(n+k)  O(n^{2})  O(n+k)  no  yes  no 
Cardinality sort  O(n*k)  O(n*k)  O(n*k)  O(n+k)  no  yes  no 
Write at the end
Sorting algorithm is the core of algorithm learning. Mastering sorting algorithm and its idea is the basis of learning other algorithms. I hope you can master it. Welcome to personal blog:Yao Shaomin’s blog。