Python 实现十大经典排序算法

5、具体示例

def selection_sort(arr):
for i in range(len(arr)-1):          # 循环第 i 趟
min_index = i                    # 记录最小数的下标
for j in range(i+1, len(arr)):   # j 为下标
if arr[j] < arr[min_index]:  # 如果这个数小于记录的最小数，则更新最小数的下标
min_index = j
arr[i], arr[min_index] = arr[min_index], arr[i]  # 将 i 位置的数（已排序序列的末尾的数）和最小数进行交换
print(arr)                       # 每一趟比较完了就打印一次

arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
selection_sort(arr)

[2, 44, 38, 5, 47, 15, 36, 26, 27, 3, 46, 4, 19, 50, 48]
[2, 3, 38, 5, 47, 15, 36, 26, 27, 44, 46, 4, 19, 50, 48]
[2, 3, 4, 5, 47, 15, 36, 26, 27, 44, 46, 38, 19, 50, 48]
[2, 3, 4, 5, 47, 15, 36, 26, 27, 44, 46, 38, 19, 50, 48]
[2, 3, 4, 5, 15, 47, 36, 26, 27, 44, 46, 38, 19, 50, 48]
[2, 3, 4, 5, 15, 19, 36, 26, 27, 44, 46, 38, 47, 50, 48]
[2, 3, 4, 5, 15, 19, 26, 36, 27, 44, 46, 38, 47, 50, 48]
[2, 3, 4, 5, 15, 19, 26, 27, 36, 44, 46, 38, 47, 50, 48]
[2, 3, 4, 5, 15, 19, 26, 27, 36, 44, 46, 38, 47, 50, 48]
[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 46, 44, 47, 50, 48]
[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 50, 48]
[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 50, 48]
[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 50, 48]
[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

三、插入排序（Insertion Sort）

1、原理

插入排序一般也被称为直接插入排序。对于少量元素的排序，它是一个有效的算法。它的基本思想是将一个记录插入到已经排好序的有序表中，从而形成一个新的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素进行遍历，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动。

插入排序的工作方式像许多人排序一手扑克牌。开始时，我们的左手为空并且桌子上的牌面向下。然后，我们每次从桌子上拿走一张牌并将它插入左手中正确的位置。为了找到一张牌的正确位置，我们从右到左将它与已在手中的每张牌进行比较。拿在左手上的牌总是排序好的，原来这些牌是桌子上牌堆中顶部的牌。

2、步骤

• ① 从第一个元素开始，该元素可以认为已经被排序；
• ② 取出下一个元素，在已经排序的元素序列中从后向前扫描；
• ③ 如果该元素（已排序的）大于新元素，将该元素往右移到下一位置，重复该步骤，直到找到已排序的元素小于或者等于新元素的位置；
• ④ 将新元素插入到步骤 ③ 找到的位置的后面；
• ⑤ 重复步骤 ② ~ ④。

3、动画演示

4、代码实现

def insertion_sort(arr):
for i in range(1, len(arr)):    # 将 i 看做摸到的牌的下标
tmp = arr[i]                # 将摸到的牌储存到 tmp
j = i-1                     # 将 j 看做手里的牌的下标
while j >= 0 and arr[j] > tmp:  # 如果手里的牌大于摸到的牌
arr[j+1] = arr[j]       # 将手里的牌往右移一个位置（将手里的牌赋值给下一个位置）
j -= 1                  # 将手里的牌的下标减 1，再次准备与摸到的牌进行比较
arr[j+1] = tmp              # 将摸到的牌插入到 j+1 位置
return arr

5、具体示例

def insertion_sort(arr):
for i in range(1, len(arr)):    # 将 i 看做摸到的牌的下标
tmp = arr[i]                # 将摸到的牌储存到 tmp
j = i-1                     # 将 j 看做手里的牌的下标
while j >= 0 and arr[j] > tmp:  # 如果手里的牌大于摸到的牌
arr[j+1] = arr[j]       # 将手里的牌往右移一个位置（将手里的牌赋值给下一个位置）
j -= 1                  # 将手里的牌的下标减 1，再次准备与摸到的牌进行比较
arr[j+1] = tmp              # 将摸到的牌插入到 j+1 位置
print(arr)                  # 每一趟比较完了就打印一次

arr = [0, 9, 8, 7, 1, 2, 3, 4, 5, 6]
insertion_sort(arr)

[0, 9, 8, 7, 1, 2, 3, 4, 5, 6]  # 手里第一张牌为 0，摸到 9，此时 i=1，j=0，0 比 9 小，将 9 插到索引 j+1=1 处。
[0, 8, 9, 7, 1, 2, 3, 4, 5, 6]  # 手里的牌为 0，9，摸到 8，此时 i=2，j=1，9 比 8 大，将 9 右移一个位置，j-1=0，将 8 插到 j+1=1 处
[0, 7, 8, 9, 1, 2, 3, 4, 5, 6]
[0, 1, 7, 8, 9, 2, 3, 4, 5, 6]
[0, 1, 2, 7, 8, 9, 3, 4, 5, 6]
[0, 1, 2, 3, 7, 8, 9, 4, 5, 6]
[0, 1, 2, 3, 4, 7, 8, 9, 5, 6]
[0, 1, 2, 3, 4, 5, 7, 8, 9, 6]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

四、希尔排序（Shell Sort）

1、原理

希尔排序是插入排序的一种更高效的改进版本，是一种分组插入排序算法，又称缩小增量排序（Diminishing Increment Sort），希尔排序是非稳定排序算法。该方法因 D.L.Shell 于 1959 年提出而得名。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

• 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
• 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；

希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

2、步骤

• ① n 为数组长度，首先取一个整数 d1=n/2，将元素分为 d1 个组，每组相邻量元素之间距离为 d1-1，在各组内进行直接插入排序；
• ② 取第二个整数 d2=d1/2，重复步骤 ① 分组排序过程，直到 di=1，即所有元素在同一组内进行直接插入排序。

PS：希尔排序每趟并不使某些元素有序，而是使整体数据越来越接近有序；最后一趟排序使得所有数据有序。

3、动画演示

4、代码实现

def insertion_sort_gap(arr, gap):     # 将 gap 看做隔 gap 个距离摸一张牌，而不是依次按照顺序摸牌
for i in range(gap, len(arr)):    # 将 i 看做摸到的牌的下标
tmp = arr[i]                  # 将摸到的牌储存到 tmp
j = i-gap                     # 将 j 看做手里的牌的下标
while j >= 0 and arr[j] > tmp:  # 如果手里的牌大于摸到的牌
arr[j+gap] = arr[j]         # 将手里的牌往右移一个位置（将手里的牌赋值给下一个位置）
j -= gap                    # 将手里的牌的下标减 gap，再次准备与摸到的牌进行比较
arr[j+gap] = tmp                # 将摸到的牌插入到 j+gap 位置

def shell_sort(arr):
d = len(arr) // 2                   # 第一次分组
while d >= 1:
insertion_sort_gap(arr, d)      # 调用插入排序
d //= 2                         # 整除 2 后再次分组
return arr

也可以不使用两个函数，写在一起即可：

def shell_sort(arr):
d = len(arr) // 2                   # 第一次分组
while d >= 1:                       # 将 d 看做隔 d 个距离摸一张牌，而不是依次按照顺序摸牌
for i in range(d, len(arr)):    # 将 i 看做摸到的牌的下标
tmp = arr[i]                # 将摸到的牌储存到 tmp
j = i - d                   # 将 j 看做手里的牌的下标
while j >= 0 and arr[j] > tmp:   # 如果手里的牌大于摸到的牌
arr[j + d] = arr[j]          # 将手里的牌往右移一个位置（将手里的牌赋值给下一个位置）
j -= d                       # 将手里的牌的下标减 d，再次准备与摸到的牌进行比较
arr[j + d] = tmp                 # 将摸到的牌插入到 j+d 位置
d //= 2                              # 整除 2 后再次分组
return arr

5、具体示例

def insertion_sort_gap(arr, gap):     # 将 gap 看做隔 gap 个距离摸一张牌，而不是依次按照顺序摸牌
for i in range(gap, len(arr)):    # 将 i 看做摸到的牌的下标
tmp = arr[i]                  # 将摸到的牌储存到 tmp
j = i-gap                     # 将 j 看做手里的牌的下标
while j >= 0 and arr[j] > tmp:  # 如果手里的牌大于摸到的牌
arr[j+gap] = arr[j]         # 将手里的牌往右移一个位置（将手里的牌赋值给下一个位置）
j -= gap                    # 将手里的牌的下标减 gap，再次准备与摸到的牌进行比较
arr[j+gap] = tmp                # 将摸到的牌插入到 j+gap 位置

def shell_sort(arr):
d = len(arr) // 2                   # 第一次分组
while d >= 1:
insertion_sort_gap(arr, d)      # 调用插入排序
print(arr)                      # 每一轮排序后打印一次
d //= 2                         # 整除 2 后再次分组

arr = [5, 7, 4, 6, 3, 1, 2, 9, 8]
shell_sort(arr)

[3, 1, 2, 6, 5, 7, 4, 9, 8]
[2, 1, 3, 6, 4, 7, 5, 9, 8]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

def shell_sort(arr):
d = len(arr) // 2                   # 第一次分组
while d >= 1:                       # 将 d 看做隔 d 个距离摸一张牌，而不是依次按照顺序摸牌
for i in range(d, len(arr)):    # 将 i 看做摸到的牌的下标
tmp = arr[i]                # 将摸到的牌储存到 tmp
j = i - d                   # 将 j 看做手里的牌的下标
while j >= 0 and arr[j] > tmp:   # 如果手里的牌大于摸到的牌
arr[j + d] = arr[j]          # 将手里的牌往右移一个位置（将手里的牌赋值给下一个位置）
j -= d                       # 将手里的牌的下标减 d，再次准备与摸到的牌进行比较
arr[j + d] = tmp                 # 将摸到的牌插入到 j+d 位置
print(arr)                           # 每一轮排序后打印一次
d //= 2                              # 整除 2 后再次分组

arr = [5, 7, 4, 6, 3, 1, 2, 9, 8]
shell_sort(arr)

[3, 1, 2, 6, 5, 7, 4, 9, 8]
[2, 1, 3, 6, 4, 7, 5, 9, 8]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

五、归并排序（Merge Sort）

1、原理

归并的概念：假设一个列表分为两段，其中每一段都是有序列表，现在将该两段合并为一个有序列表，这种操作称为一次归并。

归并排序是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

2、步骤

归并的基本步骤：

• ① 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
• ② 设定两个指针，最初位置分别为两个已经排序序列的起始位置；
• ③ 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
• ④ 重复步骤 ③ 直到某一指针达到序列尾；
• ⑤ 将另一序列剩下的所有元素直接复制到合并序列尾。

归并排序的步骤：

• ① 分解：将列表越分越小，直至分成一个元素，终止条件：一个元素是有序的。
• ② 合并：不断将两个有序列表进行归并，列表越来越大，直到所有序列归并完毕。

3、动画演示

4、代码实现

def merge(arr, low, mid, high):
# low 和 high 为整个数组的第一个和最后一个位置索引，mid 为中间位置索引
# i 和 j 为指针，最初位置分别为两个有序序列的起始位置
# ltmp 用来存放合并后的序列
i = low
j = mid+1
ltmp = []
while i <= mid and j <= high:  # 只要左右两边都有数
if arr[i] < arr[j]:        # 当左边的数小于右边的数
ltmp.append(arr[i])    # 将左边的数存入 ltmp
i += 1                 # 左边的指针往右移一位
else:                      # 当右边的数小于左边的数
ltmp.append(arr[j])    # 将右边的数存入 ltmp
j += 1                 # 右边的指针往右移一位
# 上面的 while 语句执行完后，左边或者右边没有数了
while i <= mid:                # 当左边还有数的时候
ltmp.append(arr[i])        # 将左边剩下的数全部存入 ltmp
i += 1
while j <= high:               # 当右边还有数的时候
ltmp.append(arr[j])        # 将右边剩下的数全部存入 ltmp
j += 1
arr[low:high+1] = ltmp         # 将排序后的数组写回原数组

def merge_sort(arr, low, high):       # low 和 high 为整个数组的第一个和最后一个位置索引
if low < high:                    # 至少有两个元素
mid = (low + high) // 2
merge_sort(arr, low, mid)     # 把左边递归分解
merge_sort(arr, mid+1, high)  # 把右边递归分解
merge(arr, low, mid, high)    # 做归并

5、具体示例

def merge(arr, low, mid, high):
# low 和 high 为整个数组的第一个和最后一个位置索引，mid 为中间位置索引
# i 和 j 为指针，最初位置分别为两个有序序列的起始位置
# ltmp 用来存放合并后的序列
i = low
j = mid+1
ltmp = []
while i <= mid and j <= high:  # 只要左右两边都有数
if arr[i] < arr[j]:        # 当左边的数小于右边的数
ltmp.append(arr[i])    # 将左边的数存入 ltmp
i += 1                 # 左边的指针往右移一位
else:                      # 当右边的数小于左边的数
ltmp.append(arr[j])    # 将右边的数存入 ltmp
j += 1                 # 右边的指针往右移一位
# 上面的 while 语句执行完后，左边或者右边没有数了
while i <= mid:                # 当左边还有数的时候
ltmp.append(arr[i])        # 将左边剩下的数全部存入 ltmp
i += 1
while j <= high:               # 当右边还有数的时候
ltmp.append(arr[j])        # 将右边剩下的数全部存入 ltmp
j += 1
arr[low:high+1] = ltmp         # 将排序后的数组写回原数组

def merge_sort(arr, low, high):       # low 和 high 为整个数组的第一个和最后一个位置索引
if low < high:                    # 至少有两个元素
mid = (low + high) // 2
merge_sort(arr, low, mid)     # 把左边递归分解
merge_sort(arr, mid+1, high)  # 把右边递归分解
merge(arr, low, mid, high)    # 做归并print(arr)                    # 每一次归并打印一次

arr = [7, 1, 3, 2, 6, 9, 4]
merge_sort(arr, 0, len(arr)-1)

[1, 7, 3, 2, 6, 9, 4]
[1, 7, 2, 3, 6, 9, 4]
[1, 2, 3, 7, 6, 9, 4]
[1, 2, 3, 7, 6, 9, 4]
[1, 2, 3, 7, 4, 6, 9]
[1, 2, 3, 4, 6, 7, 9]

这里是一段防爬虫文本，请读者忽略。
本文原创首发于 CSDN，作者 TRHX•鲍勃。
博客首页：https://itrhx.blog.csdn.net/
本文链接：https://itrhx.blog.csdn.net/article/details/109251836
未经授权，禁止转载！恶意转载，后果自负！尊重原创，远离剽窃！

六、快速排序（Quick Sort）

1、原理

快速排序是对冒泡排序的一种改进。顾名思义快速排序就是快，而且效率高！它是处理大数据最快的排序算法之一了。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

2、步骤

• ① 从数列中挑出一个元素，称为 “基准值”;
• ② 重新排序数列，所有元素比基准值小的放在基准值的左边，比基准值大的放在基准值的右边（相同的数可以到任一边）。在这个分区退出之后，该基准值就处于数列的中间位置。这个称为分区（partition）操作，也可以称为一次归位操作，归位操作的过程见下动图；
• ③ 递归地把小于基准值元素的子数列和大于基准值元素的子数列按照步骤 ① ② 排序。

3、动画演示

4、代码实现

def partition(arr, left, right):
# 归位操作，left，right 分别为数组左边和右边的位置索引
tmp = arr[left]
while left < right:
while left < right and arr[right] >= tmp:  # 从右边找比 tmp 小的数，如果比 tmp 大，则移动指针
right -= 1                             # 将指针左移一个位置
arr[left] = arr[right]                     # 将右边的值写到左边的空位上
while left < right and arr[left] <= tmp:   # 从左边找比 tmp 大的数，如果比 tmp 小，则移动指针
left += 1                              # 将指针右移一个位置
arr[right] = arr[left]                     # 将左边的值写到右边的空位上
arr[left] = tmp                                # 把 tmp 归位
return left                   # 返回 left，right 都可以，目的是便于后面的递归操作对左右两部分进行排序

def quick_sort(arr, left, right):          # 快速排序
if left < right:
mid = partition(arr, left, right)
quick_sort(arr, left, mid-1)       # 对左半部分进行归位操作
quick_sort(arr, mid+1, right)      # 对右半部分进行归位操作
return arr

5、具体示例

def partition(arr, left, right):
# 归位操作，left，right 分别为数组左边和右边的位置索引
tmp = arr[left]
while left < right:
while left < right and arr[right] >= tmp:  # 从右边找比 tmp 小的数，如果比 tmp 大，则移动指针
right -= 1                             # 将指针左移一个位置
arr[left] = arr[right]                     # 将右边的值写到左边的空位上
while left < right and arr[left] <= tmp:   # 从左边找比 tmp 大的数，如果比 tmp 小，则移动指针
left += 1                              # 将指针右移一个位置
arr[right] = arr[left]                     # 将左边的值写到右边的空位上
arr[left] = tmp                                # 把 tmp 归位
return left                   # 返回 left，right 都可以，目的是便于后面的递归操作对左右两部分进行排序

def quick_sort(arr, left, right):
if left < right:
mid = partition(arr, left, right)
print(arr)                         # 每次归位后打印一次
quick_sort(arr, left, mid-1)       # 对左半部分进行归位操作
quick_sort(arr, mid+1, right)      # 对右半部分进行归位操作

arr = [5, 7, 4, 6, 3, 1, 2, 9, 8]
quick_sort(arr, 0, len(arr)-1)

[2, 1, 4, 3, 5, 6, 7, 9, 8]
[1, 2, 4, 3, 5, 6, 7, 9, 8]
[1, 2, 3, 4, 5, 6, 7, 9, 8]
[1, 2, 3, 4, 5, 6, 7, 9, 8]
[1, 2, 3, 4, 5, 6, 7, 9, 8]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

七、堆排序（Heap Sort）

1、原理

堆排序是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

• 堆：一种特殊的完全二叉树结构
• 大根堆：一棵完全二叉树，满足任一节点都比其孩子节点大
• 小根堆：一棵完全二叉树，满足任一节点都比其孩子节点小

2、步骤

• ① 构建堆：将待排序序列构建成一个堆 H[0……n-1]，从最后一个非叶子结点开始，从左至右，从下至上进行调整。根据升序或降序需求选择大顶堆或小顶堆；
• ② 此时的堆顶元素，为最大或者最小元素；
• ③ 把堆顶元素和堆尾元素互换，调整堆，重新使堆有序；
• ④ 此时堆顶元素为第二大元素；
• ⑤ 重复以上步骤，直到堆变空。

3、动画演示

堆构建完成后再进行推排序：

4、代码实现

def sift(arr, low, high):
"""
:param li: 列表
:param low: 堆的根节点位置
:param high: 堆的最后一个元素的位置
"""
i = low                 # i最开始指向根节点
j = 2 * i + 1           # j开始是左孩子
tmp = arr[low]          # 把堆顶存起来
while j <= high:        # 只要j位置有数
if j + 1 <= high and arr[j+1] > arr[j]:   # 如果右孩子有并且比较大
j = j + 1       # j指向右孩子
if arr[j] > tmp:
arr[i] = arr[j]
i = j           # 往下看一层
j = 2 * i + 1
else:               # tmp更大，把tmp放到i的位置上
arr[i] = tmp    # 把tmp放到某一级领导位置上
break
else:
arr[i] = tmp        # 把tmp放到叶子节点上

def heap_sort(arr):
n = len(arr)
for i in range((n-2)//2, -1, -1):   # i表示建堆的时候调整的部分的根的下标
sift(arr, i, n-1)
# 建堆完成
for i in range(n-1, -1, -1):        # i 指向当前堆的最后一个元素
arr[0], arr[i] = arr[i], arr[0]
sift(arr, 0, i - 1)             # i-1是新的high
return arr

5、具体示例

def sift(arr, low, high):
"""
:param li: 列表
:param low: 堆的根节点位置
:param high: 堆的最后一个元素的位置
"""
i = low                 # i最开始指向根节点
j = 2 * i + 1           # j开始是左孩子
tmp = arr[low]          # 把堆顶存起来
while j <= high:        # 只要j位置有数
if j + 1 <= high and arr[j+1] > arr[j]:   # 如果右孩子有并且比较大
j = j + 1       # j指向右孩子
if arr[j] > tmp:
arr[i] = arr[j]
i = j           # 往下看一层
j = 2 * i + 1
else:               # tmp更大，把tmp放到i的位置上
arr[i] = tmp    # 把tmp放到某一级领导位置上
break
else:
arr[i] = tmp        # 把tmp放到叶子节点上

def heap_sort(arr):
n = len(arr)
print('建堆过程：')
print(arr)
for i in range((n-2)//2, -1, -1):   # i表示建堆的时候调整的部分的根的下标
sift(arr, i, n-1)
print(arr)
# 建堆完成
print('堆排序过程：')
print(arr)
for i in range(n-1, -1, -1):        # i 指向当前堆的最后一个元素
arr[0], arr[i] = arr[i], arr[0]
sift(arr, 0, i - 1)             # i-1是新的high
print(arr)

arr = [2, 7, 26, 25, 19, 17, 1, 90, 3, 36]
heap_sort(arr)

建堆过程：
[2, 7, 26, 25, 19, 17, 1, 90, 3, 36]
[2, 7, 26, 25, 36, 17, 1, 90, 3, 19]
[2, 7, 26, 90, 36, 17, 1, 25, 3, 19]
[2, 7, 26, 90, 36, 17, 1, 25, 3, 19]
[2, 90, 26, 25, 36, 17, 1, 7, 3, 19]
[90, 36, 26, 25, 19, 17, 1, 7, 3, 2]
堆排序过程：
[90, 36, 26, 25, 19, 17, 1, 7, 3, 2]
[36, 25, 26, 7, 19, 17, 1, 2, 3, 90]
[26, 25, 17, 7, 19, 3, 1, 2, 36, 90]
[25, 19, 17, 7, 2, 3, 1, 26, 36, 90]
[19, 7, 17, 1, 2, 3, 25, 26, 36, 90]
[17, 7, 3, 1, 2, 19, 25, 26, 36, 90]
[7, 2, 3, 1, 17, 19, 25, 26, 36, 90]
[3, 2, 1, 7, 17, 19, 25, 26, 36, 90]
[2, 1, 3, 7, 17, 19, 25, 26, 36, 90]
[1, 2, 3, 7, 17, 19, 25, 26, 36, 90]
[1, 2, 3, 7, 17, 19, 25, 26, 36, 90]

八、计数排序（Counting Sort）

1、原理

计数排序是一个非基于比较的排序算法，它的优势在于在对一定范围内的整数排序时，它的复杂度为 Ο(n+k)，其中 k 是整数的范围，快于任何比较排序算法。计数排序是一种牺牲空间换取时间的做法。计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

2、步骤

• ① 找到待排序列表中的最大值 k，开辟一个长度为 k+1 的计数列表，计数列表中的值都为 0。
• ② 遍历待排序列表，如果遍历到的元素值为 i，则计数列表中索引 i 的值加1。
• ③ 遍历完整个待排序列表，计数列表中索引 i 的值 j 表示 i 的个数为 j，统计出待排序列表中每个值的数量。
• ④ 创建一个新列表（也可以清空原列表，在原列表中添加），遍历计数列表，依次在新列表中添加 j 个 i，新列表就是排好序后的列表，整个过程没有比较待排序列表中的数据大小。

3、动画演示

4、代码实现

def count_sort(arr):
if len(arr) < 2:                       # 如果数组长度小于 2 则直接返回
return arr
max_num = max(arr)
count = [0 for _ in range(max_num+1)]  # 开辟一个计数列表
for val in arr:
count[val] += 1
arr.clear()                        # 原数组清空
for ind, val in enumerate(count):  # 遍历值和下标（值的数量）
for i in range(val):
arr.append(ind)
return arr

5、具体示例

def count_sort(arr):
if len(arr) < 2:                       # 如果数组长度小于 2 则直接返回
return arr
max_num = max(arr)
count = [0 for _ in range(max_num+1)]  # 开辟一个计数列表
for val in arr:
count[val] += 1
arr.clear()                        # 原数组清空
for ind, val in enumerate(count):  # 遍历值和下标（值的数量）
for i in range(val):
arr.append(ind)
return arr
arr = [2, 3, 8, 7, 1, 2, 2, 2, 7, 3, 9, 8, 2, 1, 4, 2, 4, 6, 9, 2]
sorted_arr = count_sort(arr)
print(sorted_arr)

[1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 4, 6, 7, 7, 8, 8, 9, 9]

九、桶排序（Bucket Sort）

1、原理

桶排序又叫箱排序，工作的原理是将数组分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳结果。

桶排序也是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效，我们需要做到这两点：

• 在额外空间充足的情况下，尽量增大桶的数量；
• 使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中。

同时，对于桶中元素的排序，选择何种比较排序算法对于性能的影响至关重要。

• 最快情况：当输入的数据可以均匀的分配到每一个桶中；
• 最慢情况：当输入的数据被分配到了同一个桶中。

2、步骤

• ① 创建一个定量的数组当作空桶子；
• ② 遍历序列，把元素一个一个放到对应的桶子去；
• ③ 对每个不是空的桶子进行排序；
• ④ 从不是空的桶子里把元素再放回原来的序列中。

3、动画演示

（动图来源于@五分钟学算法，侵删）

4、代码实现

def bucket_sort(arr):
max_num = max(arr)
n = len(arr)
buckets = [[] for _ in range(n)]         # 创建桶
for var in arr:
i = min(var // (max_num // n), n-1)  # i 表示 var 放到几号桶里
buckets[i].append(var)               # 把 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:
break
sorted_arr = []
for buc in buckets:
sorted_arr.extend(buc)
return sorted_arr

5、具体示例

def bucket_sort(arr):
max_num = max(arr)
n = len(arr)
buckets = [[] for _ in range(n)]         # 创建桶
for var in arr:
i = min(var // (max_num // n), n-1)  # i 表示 var 放到几号桶里
buckets[i].append(var)               # 把 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:
break
sorted_arr = []
for buc in buckets:
sorted_arr.extend(buc)
return sorted_arr
arr = [7, 12, 56, 23, 19, 33, 35, 42, 42, 2, 8, 22, 39, 26, 17]
sorted_arr = bucket_sort(arr)
print(sorted_arr)

[2, 7, 8, 12, 17, 19, 22, 23, 26, 33, 35, 39, 42, 42, 56]

十、基数排序（Radix Sort）

1、原理

基数排序属于分配式排序，是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。

基数排序、计数排序、桶排序三种排序算法都利用了桶的概念，但对桶的使用方法上是有明显差异的：

• 基数排序：根据键值的每位数字来分配桶；
• 计数排序：每个桶只存储单一键值；
• 桶排序：每个桶存储一定范围的数值。

2、步骤

• ① 取数组中的最大数，并取得位数；
• ② 从最低位开始，依次进行一次排序；
• ③ 从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。

3、动画演示

4、代码实现

def radix_sort(li):
max_num = max(li)      # 最大值 9->1次循环, 99->2次循环, 888->3次循环, 10000->5次循环
it = 0
while 10 ** it <= max_num:
buckets = [[] for _ in range(10)]
for var in li:
# var=987, it=1, 987//10->98, 98%10->8; it=2, 987//100->9, 9%10=9
digit = (var // 10 ** it) % 10   # 依次取一位数
buckets[digit].append(var)
# 分桶完成
li.clear()
for buc in buckets:
li.extend(buc)
it += 1            # 把数重新写回 li
return arr

5、具体示例

def radix_sort(li):
max_num = max(li)      # 最大值 9->1次循环, 99->2次循环, 888->3次循环, 10000->5次循环
it = 0
while 10 ** it <= max_num:
buckets = [[] for _ in range(10)]
for var in li:
# var=987, it=1, 987//10->98, 98%10->8; it=2, 987//100->9, 9%10=9
digit = (var // 10 ** it) % 10   # 依次取一位数
buckets[digit].append(var)
# 分桶完成
li.clear()
for buc in buckets:
li.extend(buc)
it += 1            # 把数重新写回 li
return arr
arr = [3221, 1, 10, 9680, 577, 9420, 7, 5622, 4793, 2030, 3138, 82, 2599, 743, 4127]
sorted_arr = radix_sort(arr)
print(sorted_arr)

[1, 7, 10, 82, 577, 743, 2030, 2599, 3138, 3221, 4127, 4793, 5622, 9420, 9680]

这里是一段防爬虫文本，请读者忽略。
本文原创首发于 CSDN，作者 TRHX•鲍勃。
博客首页：https://itrhx.blog.csdn.net/
本文链接：https://itrhx.blog.csdn.net/article/details/109251836
未经授权，禁止转载！恶意转载，后果自负！尊重原创，远离剽窃！