1 快速排序

• 时间复杂度 O(nlogn)
• 不稳定
• 在大多数情况下都是适用的，尤其在数据量大的时候性能优越性更加明显

        def quicksort(start, end, nums):if start >= end:return flag = nums[start]r_ptr = endl_ptr = startwhile (l_ptr < r_ptr):while (l_ptr < r_ptr and nums[r_ptr] >= flag):r_ptr -= 1if (l_ptr < r_ptr):nums[l_ptr] = nums[r_ptr]l_ptr += 1while (l_ptr < r_ptr and nums[l_ptr] < flag):l_ptr += 1if (l_ptr < r_ptr):nums[r_ptr] = nums[l_ptr]r_ptr -= 1nums[l_ptr] = flagquicksort(start, l_ptr - 1, nums)quicksort(l_ptr + 1, end, nums)

2 堆排序

• 时间复杂度 O(nlogn)
• 把最大堆堆顶的最大数取出，将剩余的堆继续调整为最大堆，再次将堆顶的最大数取出，这个过程持续到剩余数只有一个时结束
• 不稳定
• 建立堆和调整堆的过程中会产生比较大的开销，在元素少的时候并不适用

class MinHeap:def __init__(self):self.array = [-1]def insert_node(self, val):self.array.append(val)index = len(self.array) - 1while (index // 2 != 0):father = index // 2if self.array[father] > self.array[index]:temp = self.array[index]self.array[index] = self.array[father]self.array[father] = tempindex = fathercontinue# 未发生交换，完成插入breakdef delete_node(self):res = self.array[1]self.array[1] = self.array[-1]self.array = self.array[:-1]index = 1length = len(self.array)while (True):# 具有两个子节点if 2*index+1 <= length-1:left = self.array[index*2]right = self.array[index*2+1]if left < right:if self.array[index] > left:temp = self.array[index]self.array[index] = self.array[index*2]self.array[index*2] = tempindex = index * 2continueelse:breakelse:if self.array[index] > right:temp = self.array[index]self.array[index] = self.array[index*2+1]self.array[index*2+1] = tempindex = index * 2 + 1continueelse:break# 一个子节点elif 2*index <= length-1:if self.array[index] > self.array[index*2]:temp = self.array[index]self.array[index] = self.array[index*2]self.array[index*2] = tempindex = index * 2continueelse:break# 没有子节点else:breakreturn res

3.冒泡排序

• 时间复杂度O(n2)
• 在相邻元素相等时，它们并不会交换位置，所以冒泡排序是稳定排序

    def bubble(self, array, length):for i in range(length - 1, -1, -1):  # 外层循环：每次需要排序的长度for j in range(i):  # 内层循环：从第一个元素到第i个元素if array[j] > array[j + 1]:pre, post = array[j + 1], array[j]array[j + 1], array[j] = post, prereturn array

4.选择排序

• 时间复杂度O(n2)
• 和冒泡排序有一定的相似度，可以认为选择排序是冒泡排序的一种改进
• 是不稳定的排序算法

    def select(self, array, length):for i in range(length - 1):  # 外层循环的i代表本次循环需要填的位置min_val = array[i]min_idx = ifor j in range(i + 1, length):if min_val > array[j]:min_val = array[j]min_idx = jarray[min_idx] = array[i]array[i] = min_valreturn array

5.插入排序

• 时间复杂度O(n2)
• 把待排序的数组分成已排序和未排序两部分，初始的时候把第一个元素认为是已排好序的。从第二个元素开始，在已排好序的子数组中寻找到该元素合适的位置并插入该位置

    def insert(self, array, length):for i in range(1, length):  # 外层循环的i代表当前要处理的位置，i之前已经全部有序val = array[i]ptr = iwhile (ptr > 0 and array[ptr - 1] > val):  # 内层循环寻找插入位置array[ptr] = array[ptr - 1]ptr -= 1array[ptr] = valreturn array