排序算法

排序算法简单地分为两类：比较排序和非比较排序，其中比较排序是通过比较元素的相对大小来实现排序，其复杂度的上限为O(nlogn)，所以也称其为非线性时间排序；非比较排序不是通过比较元素相对大小来实现，通常能够以O(n)的复杂度来实现，所以也称其为线性时间排序，下面给出了十种排序算法的复杂度（时间复杂度和空间复杂度）和稳定性

其中，n 表示需要排序的元素数量，k 表示桶的数量

LB三人组

冒泡排序

冒泡排序的思想就是每次循环过程中，大的元素下降，小的元素上升，从而进行排序，具体过程如下：

代码如下：

def bubble_sort(a): n = len(a) flag = False #设置标志位，避免无效排序 for i in range(n-1, 0, -1): for j in range(i): if a[j] > a[j + 1]: a[j], a[j + 1] = a[j + 1], a[j] flag = True if not flag: break return a if __name__ == "__main__": a = [90, 5, 83, 42, 12, 15] print(bubble_sort(a))

选择排序

选择排序的思想就是每次循环的过程中找到最小的值放在第一位，依次循环找到其他较小的值放在接下来的位置，通过查找进行排序，其过程如下：

代码如下：

def select_sort(a): n = len(a) for i in range(n - 1): min_index = i for j in range(i+1, n): if a[j] < a[min_index]: min_index = j a[i], a[min_index] = a[min_index], a[i] return a if __name__ == "__main__": a = [90, 5, 83, 42, 12, 15] print(select_sort(a))

插入排序

插入排序的思想就是和之前的元素进行比较，大的元素放在后面，小的元素放在前面，具体过程如下：

代码如下：

def insert_sort(a): n = len(a) for i in range(1, n): cur_val = a[i] pos = i while pos > 0 and a[pos - 1] > cur_val: a[pos] = a[pos - 1] pos -= 1 a[pos] = cur_val return a if __name__ == "__main__": a = [90, 5, 83, 42, 12, 15] print(insert_sort(a))

希尔排序

希尔排序是插入排序的另一种变化，通过有间隔的插入排序并逐步减小间隔实现最终的排序，其过程如下：

代码如下：

def shell_sort(a): n = len(a) gap = n // 2 while gap > 0: for i in range(gap): gap_insert(a, i, gap) #有间隔的插入排序 gap //= 2 return a def gap_insert(a, sta, gap): for i in range(sta + gap, len(a), gap): cur_val = a[i] pos = i while pos > sta and a[pos - gap] > cur_val: a[pos] = a[pos - gap] pos -= gap a[pos] = cur_val return a if __name__ == "__main__": a = [90, 5, 83, 42, 12, 15] print(shell_sort(a))

NB三人组

归并排序

归并排序是基于分治的思想，将需要排序的数据分为两个子序列，对子序列进行排序，然后将排好序的子序列进行合并实现最终的排序，过程如下：

代码如下：

def merge_sort(a): if len(a) <= 1: return a n = len(a) // 2 left = merge_sort(a[:n]) #子序列归并排序 right = merge_sort(a[n:]) return merge(left, right) #合并排好序的子序列 def merge(left, right): l, r = 0, 0 res = [] while l < len(left) and r < len(right): if left[l] < right[r]: res.append(left[l]) l += 1 else: res.append(right[r]) r += 1 res.extend(left[l:]) res.extend(right[r:]) return res if __name__ == "__main__": a = [90, 5, 83, 42, 12, 15] print(merge_sort(a))

堆排序

堆排序思想是建立一个大根堆，将堆顶位置与最后一个进行交换，再建立大根堆，重复上述操作实现排序，过程如下：

代码如下：

def heap_sort(a): n = len(a) for i in range(n // 2 - 1, -1, -1): siftdown(a, i, n - 1) #建立大根堆 for j in range(n - 1, 0, -1): a[0], a[j] = a[j], a[0] #交换后，继续建立大根堆 siftdown(a, 0, j-1) return a def siftdown(a, sta, end): root = sta #根节点 while True: child = 2 * root + 1 #左孩子节点 if child > end: break if child + 1 <= end and a[child] < a[child + 1]: #存在右孩子节点 child += 1 if a[root] < a[child]: #维护大根堆 a[root], a[child] = a[child], a[root] root = child else: break return a if __name__ == "__main__": a = [90, 5, 83, 42, 12, 15] print(heap_sort(a))

快速排序

快速排序的思想是选择一个基准线，将比基准线小的放在一边，比基准线大的放在另一边，通过对两部分进行排序实现最终的排序，过程如下：

代码如下：

def quick_sort(a): if len(a) <= 1: return a left = [] right = [] base = a.pop() for x in a: if x < base: left.append(x) else: right.append(x) return quick_sort(left) + [base] + quick_sort(right) if __name__ == "__main__": a = [90, 5, 83, 42, 12, 15] print(quick_sort(a))

线性时间排序

计数排序

计数排序的思想是建立计数器，统计每个数字出现的次数，再将统计的结果输出实现最终的排序，过程如下：

代码如下：

def count_sort(a): n = len(a) max_val = max(a) count = [0] * (max_val + 1) for i in range(n): count[a[i]] += 1 res = [] for i in range(max_val + 1): for j in range(count[i]): res.append(i) return res if __name__ == "__main__": a = [90, 5, 83, 42, 12, 15] print(count_sort(a))

桶排序

桶排序的思想就是将对应范围内的元素放进桶中，对桶中的元素进行排序，然后再将元素按照顺序取出，完成最终的排序，过程如下：

代码如下：

def bucket_sort(a,n=100,max_num=10000): buckets = [[] for _ in range(n)] #创建桶 for x in a: i = min(x // (max_num // n) , n - 1) buckets[i].append(x) #将对应的数据放进桶中 for j in range(len(buckets[i]) - 1 , 0 ,-1): if buckets[i][j] < buckets[i][j - 1]: buckets[i][j] , buckets[i][j - 1] = buckets[i][j - 1] , buckets[i][j] else: break result = [] for bin in buckets: result.extend(bin) return result if __name__ == "__main__": a = [90, 5, 83, 42, 12, 15] print(bucket_sort(a))

基数排序

基数排序的思想就是将整数按位分为不同的数字，对每个数字进行比较，具体过程如下：

代码如下：

def radix_sort(a): max_val = max(a) it = 0 while 10 ** it <= max_val: buckets = [[] for _ in range(10)] for x in a: i = (x // (10 ** it)) % 10 buckets[i].append(x) a = [j for i in buckets for j in i] it += 1 return a if __name__ == "__main__": a = [90, 5, 83, 42, 12, 15] print(radix_sort(a))