常见排序原理及 python 实现

时间复杂度与空间复杂度

常用O(1)或O(n)表示，其中1表示一个单位(最简单的单位，可以是多个或1个，但在时间上总体是较低且连续的)，时间通常指的是程序运行时间，空间则是指程序在运行时所占用的内存空间。各个阶段的复杂度可用下面的顺序比较:

O(1) < O(logn) < O(n) < O(nlogn) < O(n2) ... 注意：
1. O(n2) 表示 O(n的平方)
2. O(logn) 表示时间(或空间)单位相对于n的对数，即：假设时间(或空间)的k次方为n，logn 表示实际复杂度为k

注意递归必定具有空间复杂度，因为系统需要开辟空间来记录每次函数递归前的状态，以便结果返回时调用。

递归与汉洛塔

递归有两个特点:

	- 调用自身- 有明确的终止条件

汉罗塔问题则是一个很好的递归例子，通过Python实现如下:

def hanoi(n, a, b, c):"""将 n 个盘子从柱子 a 经过 柱子 b 移动到柱子 c步骤如下：首先需要将 n-1 个盘子经过柱子 c 移动到柱子 b此时柱子 a 只剩一个盘子(最底部的大盘子)，柱子 c 为空然后将柱子 a 的盘子 移动到柱子 c此时柱子 a 为空最后将 n-1 个盘子经过柱子 a 移动到柱子 c此时所有盘子都在柱子 c上n 为要移动的 n 个盘子a 柱子 ab 柱子 bc 柱子 c注意三个参数的顺序"""if n > 0:hanoi(n-1, a, c, b)print(f'Moving {a} to {c}')hanoi(n-1, b, a, c)

查找

查找一般来说是在某个对象(列表、集合等)中找到指定的元素所在位置。

顺序查找

顺序查找的时间复杂度为O(n)，实现如下:

def linear_search(li, val):"""遍历并比较，找到合适的值的索引并返回"""for index, value in li:if value == val:return indexelse:return None

二分查找

二分查找的时间复杂度为O(logn)，但前提是只能对经过排序后的列表产生作用，如果拿到的是未经排序的列表，那么对列表进行排序的时间复杂度为O(n)。假定拿到的是已经排好序的列表，那么二分法实现如下:

def binary_search(li, val):"""每次取中间值，找到待索引区域直到找到指定的值或没有中间值为止"""left = 0right = len(li) - 1while right >= left:mid = (left + right) // 2value = li[mid]if value == val:return midelif value > val:right = mid - 1else:left = mid + 1else:return None

排序

冒泡排序

遍历列表的每一个值，如果当前值大于当前值的后面一个值，则交换两个值的位置，使较大的值处于后面。重复遍历直到排好序为止。
算法实现:

def bubble_sort(li):"""冒泡排序遍历 len(li)-1 趟 (从0开始)"""cycles = len(li) - 1for i in range(cycles):is_exchanged = Falsefor j in range(cycles - 1):if li[j] > li[j+1]:li[j], li[j+1] = li[j+1], li[j]if not is_exchanged:is_exchanged = Trueif not is_exchanged:break

选择排序

遍历列表，找到最小的值，将它放到一个新的位置。如此反复直到剩下的所有值都转移到新位置为止。算法实现:

def select_sort(li):"""选择排序遍历 len(li) - 1 趟 (从0开始)"""li_length = len(li)for i in range(li_length-1):# 找到并记录最小元素所在位置min_loc = i     for j in range(i+1, li_length):if li[j] < li[min_loc]:min_loc = jif min_loc != i:li[min_loc], li[i] = li[i], li[min_loc]

插入排序

插入排序类似于摸牌，每当摸到一张新牌时，就和手里面的牌依次进行比较，如果小于被比较的牌，则将被比较的牌往后移一位，直到大于被比较的牌或前面没有牌可以比较时(即摸到的牌为当前手里牌最小的牌)，将摸到的牌插入到当前位置的后一位。算法实现：

def insert_sort(li):"""插入排序类似于打牌，从列表中依次取一张牌用获取的牌与手中的牌依次对比如果获取的牌比对比的牌小，则将它插入到对比的牌的前面"""for i in range(1, len(li)):# 假定第一张牌为手中的牌# i 表示获取的牌的下标tmp = li[i]# j 表示手里牌的下标j = i - 1while j >= 0 and li[j] > tmp:li[j+1] = li[j]j -= 1li[j+1] = tmp

快速排序

从列表中随机选一个数，并将它重新放到列表中，使得它左边的数都比它小，它右边的数都比它大。根据它的位置将列表分为两部分，再依次对这两部分执行同样的操作，最后递归直到所有数都按顺序排好为止。
快速排序的复杂度是O(nlogn)，而上面三种(冒泡、选择、插入)的复杂度为O(n^2)，因此快速排序实现较快。但仍有极低概率出现最坏的情况，使得快速排序的复杂度为O(n^2)。算法实现:

"""
Quick sort
"""
import randomdef quick_sort(li, left, right):"""快速排序算法"""if left < right:mid = partition(li, left, right)quick_sort(li, left, mid-1)quick_sort(li, right, mid+1)def partition(li, left, right):"""从给定列表的指定范围随机抽取一个数 x找到 x 在列表中的相应位置 pos使得列表中所有 pos 左边的数都比 x 小所有 pos 右边的数都比 x 大将 x 放到列表中 pos 所在的位置并返回 pos"""pos = random.randint(left, right)tmp = li[pos]while left < right:# 由于取出了tmp# 可以视作tmp所在列表中的位置为一个空位# 先从空位的左边部分从左往右开始寻找# 如果出现某个数大于tmp# 那么交换两个数的位置while left < pos and li[left] <= tmp:left += 1li[pos] = li[left]pos = left# 同理从右往左找while pos < right and li[right] >= tmp:right -= 1li[pos] = li[right]pos = right# 最后将 tmp 放到 pos 所在位置# 使得: pos 左边的数都比 tmp 小，#      pos 右边的数都比 tmp 大li[pos] = tmpreturn posif __name__ == '__main__':li = list(range(10000, 0, -1))# random.shuffle(li)print(li)quick_sort(li, 0, len(li)-1)print(li)

堆排序

前言 - 树与堆

1. 树

- 定义树是一种数据结构，从一个点出发，分散为多个点，每一个分散的点又可以分散为多个点，照此依次递归直到不再有分散的点为止。- 节点其最顶部的节点被称为树的根节点，最底部的节点被称为叶子节点(即不再有延申)。树的每个度关联着父节点和子节点，子节点是从父节点延申出来的。- 度每次分散的维度(次数)又被称为度，树的度则是取树中最大的度。

2. 二叉树

- 定义二叉树是树中的一种特殊结构，表示树的每个节点的子节点不超过两个。- 满二叉树二叉树的每一个节点都有两个子节点(叶子节点除外，因为它没有子节点)。- 完全二叉树从树的顶部往下，有不间断的子节点，直到叶子节点。叶子节点右边可以不完整，但从左往最右的部分不能出现断裂。

3. 完全二叉树与列表

将完全二叉树的每个节点，从顶至下，且从左至右依次取出，依次放入一个列表中，如：9/     \8       7/ \     / \6   5   4   3/ \2   1转化为列表：[9, 8, 7, 6, 5, 4, 3, 2, 1]下标：    0, 1, 2, 3, 4, 5, 6, 7, 8那么此时，给定任意节点在列表中的位置 i ，
可以根据固定的公式找到其父节点和左右子节点所在位置：左边子节点 l:l = 2i + 1右边子节点 r:r = 2i + 2父节点 f：f = i - 1 // 2

4. 堆

- 定义堆是一种特殊的完全二叉树结构，它分为：a. 大根堆 任一节点比其子节点大b. 小根堆任一节点比其子节点小

注意：当根节点的左右子树都是堆，但其自身不是堆时，可以通过一次向下调整使其变为堆，比如:

0/     \8       7/ \     / \6   5   4   3/ \2   1||\/8/     \6       7/ \     / \2   5   4   3/ \0   1过程描述：0首先和8比较，因为小于8所以和8交换位置，依次继续和其子节点进行比较，如果小于其子节点则交换位置，直到不再小于其子节点或没有子节点为止。

5. 构造堆

对任一完全二叉树，都可以通过下面的方法将其转化为堆：假定有完全二叉树如下：0/     \4       6/ \     / \9   1   7   2/ \3   5现将二叉树拆分为一个个小的子二叉树，
比如最下面的 5,3,9 为一个子二叉树，依次是:4 6           9   1             ...7   2        3 5接下来对每一个子二叉树进行一次向下调整，使其变为一个堆。
比如最后的子二叉树调整为(因为符合堆的特征所以没有调整):9              9/ \      =>    / \3   5          3   52,7,6调整为：6              7/ \      =>    / \7   2          6   25,3,1,9,4 调整为：4              9/ \      =>    / \9   1          5   1/ \            / \3   5          3   4最后，这个完全二叉树就会变成一个堆：9/     \5       7/ \     / \4   1   6   2/ \3   0实际上就是对每一个子二叉树进行向下调整，
每当最下面的子二叉树稻城堆条件时，将其整合到上面一层，
然后再对整合后的二叉树进行向下调整，如此往复

堆排序

堆排序本质上就是把列表当作一个完全二叉树，然后从二叉树的最后一个叶子节点所在的最下子二叉树开始，一步步的构造一个堆(大根堆或小根堆)，构造完堆后，即可根据堆的特性一次次的弹出一个数并保存到列表的最后，同时缩小堆的规模(去掉最后一个数，这个数是已经排好序的)，如此往复直到堆被缩小到0为止，此时的列表就变为了一个有序列表了。
堆排序的时间复杂度为O(nlogn)。

代码实现：

1. 向下调整的代码实现:

def sift(li, low, high):"""对堆进行向下调整使得在指定范围内的二叉树变为堆结构:param li: 列表:param low: 二叉树顶点位置 即根节点位置:param high 指定范围内的二叉树的最后一个元素所在位置"""# i 指向堆顶点# left 指向 i 的左孩子# tmp 用于保存顶部变量i = lowleft = i * 2 + 1tmp = li[i]while left <= high:# 从左右节点中找出最大的元素# 赋值给largerlarger = leftright = left + 1if right <= high and li[right] > li[left]:larger = right# 将左右孩子中最大的元素与顶点进行比较if li[larger] > tmp:# 如果大于顶点则将顶点置为最大的孩子元素# 同时重新对 顶点和顶点的左孩子进行赋值# 即向下看一层li[i] = li[larger]i = largerleft = i * 2 + 1else:# 如果不大于则表示本次向下调整完成# 结束循环break# 最后将缓存的顶点元素放到 i 指向的位置# 此时 i 如果未调整则是顶点元素# 如果经过调整则是左右孩子中的任一个孩子所在位置li[i] = tmp

2. 堆排序实现：

def heap_sort(li):length = len(li)# 构造堆# 从下往上 找到每一个子完全二叉树的顶点# 顶点位置是相邻的# 进行向下调整left = length - 1top = (left - 1) // 2for i in range(top, -1, -1):sift(li, i, left)# 从后往前遍历堆的每一个元素# 取出堆的根节点(即列表的最大值)# 与堆的最后一个叶子元素进行交换# 并将堆的范围缩减一个元素(即排除最后一个叶子元素，也是列表的最大值)# 对堆进行一次向下调整# 重复上面的步骤，即可完成堆排序for i in range(left, -1, -1):li[0], li[i] = li[i], li[0]sift(li, 0, i-1)

堆排序与topk

topk问题是指从一个列表中找到排名前k的值，有如下几种思路用来解决该问题：

    - 排序后切片 时间复杂度为 O(nlogn)- 冒泡/选择/插入排序(只需要排k次) 时间复杂度为 O(kn)- 堆排序思路 时间复杂度为 O(klogn)

上面三种思路中，堆排序思路是时间复杂度是最低的。使用堆排序解决topk问题的大致思路如下:

    1. 取列表的前k个值构造一个小根堆，假定堆顶就是目前第k大的数2. 在列表中从k往后依次取出一个值与小根堆的根节点值进行比较，如果小于该节点值则忽略该元素，否则将堆顶更换为该元素，并重新进行一次向下调整3. 遍历完成后，前k个值则为反序的列表中最大的k个元素

实现代码如下:

def sift(li, low, high):"""对堆进行向下调整使得在指定范围内的二叉树变为堆结构:param li: 列表:param low: 二叉树顶点位置 即根节点位置:param high 指定范围内的二叉树的最后一个元素所在位置注意与上面的sift函数比较，上面sift中的 > 符号在此处全部变为了 <这表示构造出来的堆是一个小根堆"""i = lowleft = i * 2 + 1tmp = li[i]while left <= high:larger = leftright = left + 1if right <= high and li[right] < li[left]:larger = rightif li[larger] < tmp:li[i] = li[larger]i = largerleft = i * 2 + 1else:breakli[i] = tmpdef topk(li, k):"""找出 li 中最大的 k 个数但是不改变 li 的结构返回一个长度为 k 的有序列表"""# 对 li 的前 k 个元素构造堆heap = li[0:k]left = k - 1top = (left - 1) // 2for i in range(top, -1, -1):sift(heap, i, left)# 遍历 li 中 k 后面的值并与堆顶进行比较end = len(li) - 1for i in range(k, end):if li[i] > heap[0]:heap[0] = li[i]sift(heap, 0, left)# 对构造的堆进行排序for i in range(left, -1, -1):heap[0], heap[i] = heap[i], heap[0]sift(heap, 0, i-1)# 返回包含前 k 个元素的列表return heap

归并排序

1. 归并的含义：

    对两个有序的列表进行一定操作，归并为一个有序的列表。具体操作如下：假定有如下两个有序列表，分别为 li1, li2：1， 5， 8，        3， 6， 9 此时开辟一个新的临时列表 tmp分别依次从 li1, li2 中的第一个元素开始，假定分别为 x, y，且 x 大于 y比较两个元素的大小，将较小的元素(y)放到临时列表中，留下较大的元素(x)与 li2 的下一个元素进行比较重复上面的步骤，最后即可得到一个新的有序列表

2. 归并排序：

    归并排序是将列表分解为两个部分在将分解后的两个部分各分解为两个部分以此重复，直到最后分解后的两个部分为两个有序的列表时也就是两个列表各自包含的元素为0个或一个时对两个列表进行归并即可简单来说，归并排序与堆排序有些类似，二者都是知晓某个原理(堆/归并)，再构造条件运用该原理从而实现排序

3. 代码实现：

def merge(li, low, mid, high):"""归并对指定范围内的列表元素进行归并操作并用归并后的结果覆盖该列表相应范围内的元素"""# 创建一个临时列表# 将原列表指定范围内的数据切分为两部分# 并用变量 j 指向第二部分的初始位置# 用变量 i 指向第一部分的初始位置tmp = []i = lowj = mid + 1# 取出两部分的第一个元素进行比较# 将较小的元素放到临时列表中# 再往后查找新的元素进行比较# 直到有一个部分的元素已全部取出为止while i <= mid and j <= high:if li[i] < li[j]:tmp.append(li[i])i += 1else:tmp.append(li[j])j += 1# 分别检查两个部分# 如果还有剩余的元素# 则依次添加到临时列表中while i <= mid:tmp.append(li[i])i += 1while j <= high:tmp.append(li[j])j += 1# 将临时列表的数据写入到原列表对应的位置# 注意覆盖范围需要包含 high# 所以使用 high+1li[low:high+1] = tmpdef merge_sort(li, low=0, high=None):"""归并排序不断将列表分为两个部分直到两个部分都为有序时(包含元素为1个或0个时)进行归并"""# 第一次递归前if high is None:high = len(li) - 1# 至少有两个元素 递归if low < high:mid = (low + high) // 2merge_sort(li, low, mid)merge_sort(li, mid + 1, high)merge(li, low, mid, high)

4. 归并排序的时间复杂度与空间复杂度

    因为涉及到创建新的列表以及递归所以归并排序也存在空间复杂度，它的空间复杂度为 O(n)时间复杂度为 O(nlogn)

几种排序对比

注：

1. 快排涉及递归，所以存在空间复杂度；
2. 稳定性是指再存在两个相同元素的情况下，两个相同元素的相对位置是否变动，如果相对位置发生了改变，则不稳定，反之即稳定。一般来说，对列表进行挨次调整的算法(如冒泡排序、归并排序等)是稳定的，而跳着调整的算法(如插入排序、快速排序)则不稳定。

希尔排序

1. 希尔排序是在插入排序的基础上做的改良。大体思路如下：

    假定列表长度为 n以某个数 d 为基点，这个数需大于 0 小于 n， 假定为 n // 2从列表的起始位置开始，以 d 为间隔，每隔 d 个单位从列表中去一个值直到列表末尾把取出的值视作一个列表，对这个列表进行插入排序重复上面的步骤直到列表中的值取完为止此时将 d 设为 d // 2继续重复上面的步骤直到 d 变为 1 时，进行最后一次插入排序结束后排序完成

2. 代码实现：

def insert_sort_gap(li, gap):"""有间隔的插入排序"""for i in range(gap, len(li)):tmp = li[i]j = i - gapwhile j >= 0 and li[j] > tmp:li[j+gap] = li[j]j -= gapli[j+gap] = tmpdef shell_sort(li):"""希尔排序"""d = len(li) // 2while d >= 1:insert_sort_gap(li, d)d //= 2

3. 复杂度

    希尔排序的时间复杂度介于 O(n) 到 O(n^2) 之间这取决于 d 的取值(不同的取值方法会导致不同的时间复杂度)目前取值方法中最快的时间复杂度为:O(nlog2n)  即O(n*logn*logn)具体可参见维基百科

计数排序

1. 概念

    假定已知一个未知长度的列表中的元素全都介于 0-100 之间这个列表为 li创建一个新的元素全部为 0 且长度为 100 的列表 tmp遍历 li 中的每一个元素用 tmp 统计该元素的出现次数清空 li将 tmp 中存储的元素及出现次数依次写入到 li 中排序完成

2. 代码实现

def count_sort(li, max_count):"""计数排序:param li: 需要排序的列表:param max_count: 列表元素的最大值该列表中的所有值介于 0 到 max_count 之间"""# 创建临时列表用于计数tmp = [0 for _ in range(max_count+1)]for i in li:tmp[i] += 1# 将统计好的结果重新写入到 li 中li.clear()for index, val in enumerate(tmp):for i in range(val):li.append(index)

3. 复杂度

    由于计数排序需要创建新的列表，所以存在空间复杂度，最大为 O(n)其时间复杂度为 O(n)

桶排序

1. 概念

    桶排序基于计数排序假定有一个列表 lili 列表中的数最大值为10000分 10 个列表(即桶)分别对应： 0-9999 10000-19999 20000-29999 ... 的数值范围遍历 li 按 0-9999 10000-19999 20000-29999 ... 的范围区分每个数 并将数放入相应的桶中放入时可做相应的排序，保持桶内的数有序完成后将所有的桶重新组成一个列表此时排序完成

2. 代码实现

def bucket_sort(li, n=100, max_num=10000):"""桶排序:param n: 分为多少个桶:param max_num: 列表中的最大值"""# 创建桶buckets = [[] for _ in range(n)]for var in li:# 找到元素属于哪个桶# 注意当 var == max_num 时# var // (max_num // n) == 10# 所以需要考虑到这种情况# 因此使用 mini = min(var // (max_num // n), n-1)# 将元素放入相应的桶中buckets[i].append(var)# 保持桶内有序(插入排序)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:breakli.clear()for bucket in buckets:li.extend(bucket)

3. 复杂度

    桶排序的时间复杂度为 O(n+k) ~ O(n2k)空间复杂度为 O(nk)桶排序的表现取决于数据的分布，也就是需要对数据排序时采取不同的分桶策略

基数排序

1. 概念

    基数排序类似于桶排序，但分桶策略有所不同首先找到列表中的最大数并算出这个数的位数 k (比如: 1000 -> 3,  99999 -> 5)首先遍历列表，对列表中所有值按个位数排序(分别放入 0-9 10个桶中)再次遍历列表，... 按十位数进行排序...遍历 k 次最后列表即为有序    

2. 代码实现

def radix_sort(li):"""基数排序"""# 找到列表中最大的值的位数并遍历k = 0max_num = max(li)while 10 ** k <= max_num:# 创建桶buckets = [[] for _ in range(10)]# 遍历列表for val in li:# 找到当前 k 对应的位数的值 并放入对应的桶中# 89 & k=0 -> 9# 89 & k=5 -> 0digit = (val // 10 ** k) % 10buckets[digit].append(val)# 重置列表li.clear()for bucket in buckets:li.extend(bucket)k += 1