-
小白备战大厂算法笔试(九)——九大排序算法
排序
评价维度：
-
运行效率：我们期望排序算法的时间复杂度尽量低，且总体操作数量较少（即时间复杂度中的常数项降低）。对于大数据量情况，运行效率显得尤为重要。
-
就地性：顾名思义，原地排序通过在原数组上直接操作实现排序，无须借助额外的辅助数组，从而节省内存。通常情况下，原地排序的数据搬运操作较少，运行速度也更快。
-
稳定性：稳定排序在完成排序后，相等元素在数组中的相对顺序不发生改变。稳定排序是多级排序场景的必要条件。假设我们有一个存储学生信息的表格，第 1 列和第 2 列分别是姓名和年龄。在这种情况下，非稳定排序可能导致输入数据的有序性丧失。
# 输入数据是按照姓名排序好的 # (name, age) ('A', 19) ('B', 18) ('C', 21) ('D', 19) ('E', 23) # 假设使用非稳定排序算法按年龄排序列表， # 结果中 ('D', 19) 和 ('A', 19) 的相对位置改变， # 输入数据按姓名排序的性质丢失 ('B', 18) ('D', 19) ('A', 19) ('C', 21) ('E', 23)- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
-
自适应性：自适应排序的时间复杂度会受输入数据的影响，即最佳、最差、平均时间复杂度并不完全相等。自适应性需要根据具体情况来评估。如果最差时间复杂度差于平均时间复杂度，说明排序算法在某些数据下性能可能劣化，因此被视为负面属性；而如果最佳时间复杂度优于平均时间复杂度，则被视为正面属性。
-
是否基于比较：基于比较的排序依赖于比较运算符（<、=、>）来判断元素的相对顺序，从而排序整个数组，理论最优时间复杂度为 O(nlogn) 。而非比较排序不使用比较运算符，时间复杂度可达 O(n) ，但其通用性相对较差。
理想排序算法应当运行快、原地、稳定、正向自适应、通用性好。
选择排序
选择排序的工作原理非常直接：开启一个循环，每轮从未排序区间选择最小的元素，将其放到已排序区间的末尾。
设数组的长度为 n，选择排序的算法流程如图 11-2 所示。
- 初始状态下，所有元素未排序，即未排序（索引）区间为 [0,n−1] 。
- 选取区间 [0,n−1] 中的最小元素，将其与索引 0 处元素交换。完成后，数组前 1 个元素已排序。
- 选取区间 [1,n−1] 中的最小元素，将其与索引 1 处元素交换。完成后，数组前 2 个元素已排序。
- 以此类推。经过 n−1 轮选择与交换后，数组前 n−1 个元素已排序。
- 仅剩的一个元素必定是最大元素，无须排序，因此数组排序完成。
在代码中，用 k 来记录未排序区间内的最小元素。
Python：
def selection_sort(nums: list[int]): """选择排序""" n = len(nums) # 外循环：未排序区间为 [i, n-1] for i in range(n - 1): # 内循环：找到未排序区间内的最小元素 k = i for j in range(i + 1, n): if nums[j] < nums[k]: k = j # 记录最小元素的索引 # 将该最小元素与未排序区间的首个元素交换 nums[i], nums[k] = nums[k], nums[i]- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
Go：
/* 选择排序 */ func selectionSort(nums []int) { n := len(nums) // 外循环：未排序区间为 [i, n-1] for i := 0; i < n-1; i++ { // 内循环：找到未排序区间内的最小元素 k := i for j := i + 1; j < n; j++ { if nums[j] < nums[k] { // 记录最小元素的索引 k = j } } // 将该最小元素与未排序区间的首个元素交换 nums[i], nums[k] = nums[k], nums[i] } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 时间复杂度为 O(n^2)、非自适应排序：外循环共 n−1 轮，第一轮的未排序区间长度为 n ，最后一轮的未排序区间长度为 2 ，即各轮外循环分别包含 n、n−1、…、3、2 轮内循环，求和为 (n−1)(n+2)2 。
- 空间复杂度 O(1)、原地排序：指针 i 和 j 使用常数大小的额外空间。
- 非稳定排序：元素
nums[i]有可能被交换至与其相等的元素的右边，导致两者相对顺序发生改变。
冒泡排序
冒泡排序通过连续地比较与交换相邻元素实现排序。冒泡过程可以利用元素交换操作来模拟：从数组最左端开始向右遍历，依次比较相邻元素大小，如果“左元素 > 右元素”就交换它俩。遍历完成后，最大的元素会被移动到数组的最右端。
设数组的长度为 n ，冒泡排序的步骤如下：
- 首先，对 n 个元素执行“冒泡”，将数组的最大元素交换至正确位置，
- 接下来，对剩余 n−1 个元素执行“冒泡”，将第二大元素交换至正确位置。
- 以此类推，经过 n−1 轮“冒泡”后，前 n−1 大的元素都被交换至正确位置。
- 仅剩的一个元素必定是最小元素，无须排序，因此数组排序完成。
Python：
def bubble_sort(nums: list[int]): """冒泡排序""" n = len(nums) # 外循环：未排序区间为 [0, i] for i in range(n - 1, 0, -1): # 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 for j in range(i): if nums[j] > nums[j + 1]: # 交换 nums[j] 与 nums[j + 1] nums[j], nums[j + 1] = nums[j + 1], nums[j]- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
Go：
/* 冒泡排序 */ func bubbleSort(nums []int) { // 外循环：未排序区间为 [0, i] for i := len(nums) - 1; i > 0; i-- { // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 for j := 0; j < i; j++ { if nums[j] > nums[j+1] { // 交换 nums[j] 与 nums[j + 1] nums[j], nums[j+1] = nums[j+1], nums[j] } } } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
如果某轮“冒泡”中没有执行任何交换操作，说明数组已经完成排序，可直接返回结果。因此，可以增加一个标志位
flag来监测这种情况，一旦出现就立即返回。经过优化，冒泡排序的最差和平均时间复杂度仍为 O(n^2) ；但当输入数组完全有序时，可达到最佳时间复杂度 O(n) 。Python：
def bubble_sort_with_flag(nums: list[int]): """冒泡排序（标志优化）""" n = len(nums) # 外循环：未排序区间为 [0, i] for i in range(n - 1, 0, -1): flag = False # 初始化标志位 # 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 for j in range(i): if nums[j] > nums[j + 1]: # 交换 nums[j] 与 nums[j + 1] nums[j], nums[j + 1] = nums[j + 1], nums[j] flag = True # 记录交换元素 if not flag: break # 此轮冒泡未交换任何元素，直接跳出- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
Go：
/* 冒泡排序（标志优化）*/ func bubbleSortWithFlag(nums []int) { // 外循环：未排序区间为 [0, i] for i := len(nums) - 1; i > 0; i-- { flag := false // 初始化标志位 // 内循环：将未排序区间 [0, i] 中的最大元素交换至该区间的最右端 for j := 0; j < i; j++ { if nums[j] > nums[j+1] { // 交换 nums[j] 与 nums[j + 1] nums[j], nums[j+1] = nums[j+1], nums[j] flag = true // 记录交换元素 } } if flag == false { // 此轮冒泡未交换任何元素，直接跳出 break } } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 时间复杂度为 O(n^2)、自适应排序：各轮“冒泡”遍历的数组长度依次为 n−1、n−2、…、2、1 ，总和为 (n−1)n/2 。在引入
flag优化后，最佳时间复杂度可达到 O(n) 。 - 空间复杂度为 O(1)、原地排序：指针 i 和 j 使用常数大小的额外空间。
- 稳定排序：由于在“冒泡”中遇到相等元素不交换。
插入排序
插入排序是一种简单的排序算法，它的工作原理与手动整理一副牌的过程非常相似。
具体来说，在未排序区间选择一个基准元素，将该元素与其左侧已排序区间的元素逐一比较大小，并将该元素插入到正确的位置。
插入排序的整体流程如下：
- 初始状态下，数组的第 1 个元素已完成排序。
- 选取数组的第 2 个元素作为
base，将其插入到正确位置后，数组的前 2 个元素已排序。 - 选取第 3 个元素作为
base，将其插入到正确位置后，数组的前 3 个元素已排序。 - 以此类推，在最后一轮中，选取最后一个元素作为
base，将其插入到正确位置后，所有元素均已排序。
Python：
def insertion_sort(nums: list[int]): """插入排序""" # 外循环：已排序区间为 [0, i-1] for i in range(1, len(nums)): base = nums[i] j = i - 1 # 内循环：将 base 插入到已排序区间 [0, i-1] 中的正确位置 while j >= 0 and nums[j] > base: nums[j + 1] = nums[j] # 将 nums[j] 向右移动一位 j -= 1 nums[j + 1] = base # 将 base 赋值到正确位置- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
Go：
/* 插入排序 */ func insertionSort(nums []int) { // 外循环：未排序区间为 [0, i] for i := 1; i < len(nums); i++ { base := nums[i] j := i - 1 // 内循环：将 base 插入到已排序部分的正确位置 for j >= 0 && nums[j] > base { nums[j+1] = nums[j] // 将 nums[j] 向右移动一位 j-- } nums[j+1] = base // 将 base 赋值到正确位置 } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 时间复杂度 O(n^2)、自适应排序：最差情况下，每次插入操作分别需要循环 n−1、n−2、…、2、1 次，求和得到 (n−1)n/2 ，因此时间复杂度为 O(n^2) 。在遇到有序数据时，插入操作会提前终止。当输入数组完全有序时，插入排序达到最佳时间复杂度 O(n) 。
- 空间复杂度 O(1)、原地排序：指针 i 和 j 使用常数大小的额外空间。
- 稳定排序：在插入操作过程中，我们会将元素插入到相等元素的右侧，不会改变它们的顺序。
虽然冒泡排序、选择排序和插入排序的时间复杂度都为 O(n^2) ，但在实际情况中，插入排序的使用频率显著高于冒泡排序和选择排序，主要有以下原因。
- 冒泡排序基于元素交换实现，需要借助一个临时变量，共涉及 3 个单元操作；插入排序基于元素赋值实现，仅需 1 个单元操作。因此，冒泡排序的计算开销通常比插入排序更高。
- 选择排序在任何情况下的时间复杂度都为 O(n^2) 。如果给定一组部分有序的数据，插入排序通常比选择排序效率更高。
- 选择排序不稳定，无法应用于多级排序。
快速排序
快速排序是一种基于分治策略的排序算法，运行高效，应用广泛。
快速排序的核心操作是“哨兵划分”，其目标是：选择数组中的某个元素作为“基准数”，将所有小于基准数的元素移到其左侧，而大于基准数的元素移到其右侧。
- 选取数组最左端元素作为基准数，初始化两个指针
i和j分别指向数组的两端。 - 设置一个循环，在每轮中使用
i（j）分别寻找第一个比基准数大（小）的元素，然后交换这两个元素。 - 循环执行步骤
2.，直到i和j相遇时停止，最后将基准数交换至两个子数组的分界线。
哨兵划分完成后，原数组被划分成三部分：左子数组、基准数、右子数组，且满足“左子数组任意元素 ≤ 基准数 ≤ 右子数组任意元素”。接下来只需对这两个子数组进行排序。哨兵划分的实质是将一个较长数组的排序问题简化为两个较短数组的排序问题。然后，对左子数组和右子数组分别递归执行“哨兵划分”。持续递归，直至子数组长度为 1 时终止，从而完成整个数组的排序。
Python：
def partition(self, nums: list[int], left: int, right: int) -> int: """哨兵划分""" # 以 nums[left] 作为基准数 i, j = left, right while i < j: while i < j and nums[j] >= nums[left]: j -= 1 # 从右向左找首个小于基准数的元素 while i < j and nums[i] <= nums[left]: i += 1 # 从左向右找首个大于基准数的元素 # 元素交换 nums[i], nums[j] = nums[j], nums[i] # 将基准数交换至两子数组的分界线 nums[i], nums[left] = nums[left], nums[i] return i # 返回基准数的索引 def quick_sort(self, nums: list[int], left: int, right: int): """快速排序""" # 子数组长度为 1 时终止递归 if left >= right: return # 哨兵划分 pivot = self.partition(nums, left, right) # 递归左子数组、右子数组 self.quick_sort(nums, left, pivot - 1) self.quick_sort(nums, pivot + 1, right)- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
Go:
/* 哨兵划分 */ func (q *quickSort) partition(nums []int, left, right int) int { // 以 nums[left] 作为基准数 i, j := left, right for i < j { for i < j && nums[j] >= nums[left] { j-- // 从右向左找首个小于基准数的元素 } for i < j && nums[i] <= nums[left] { i++ // 从左向右找首个大于基准数的元素 } // 元素交换 nums[i], nums[j] = nums[j], nums[i] } // 将基准数交换至两子数组的分界线 nums[i], nums[left] = nums[left], nums[i] return i // 返回基准数的索引 } /* 快速排序 */ func (q *quickSort) quickSort(nums []int, left, right int) { // 子数组长度为 1 时终止递归 if left >= right { return } // 哨兵划分 pivot := q.partition(nums, left, right) // 递归左子数组、右子数组 q.quickSort(nums, left, pivot-1) q.quickSort(nums, pivot+1, right) }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 时间复杂度 O(nlogn)、自适应排序：在平均情况下，哨兵划分的递归层数为 logn ，每层中的总循环数为 n ，总体使用 O(nlogn) 时间。在最差情况下，每轮哨兵划分操作都将长度为 n 的数组划分为长度为 0 和 n−1 的两个子数组，此时递归层数达到 n 层，每层中的循环数为 n ，总体使用 O(n^2) 时间。
- 空间复杂度 O(n)、原地排序：在输入数组完全倒序的情况下，达到最差递归深度 n ，使用 O(n) 栈帧空间。排序操作是在原数组上进行的，未借助额外数组。
- 非稳定排序：在哨兵划分的最后一步，基准数可能会被交换至相等元素的右侧。
尽管快速排序的平均时间复杂度与“归并排序”和“堆排序”相同，但通常快速排序的效率更高，主要有以下原因。
- 出现最差情况的概率很低：虽然快速排序的最差时间复杂度为 O(n^2) ，没有归并排序稳定，但在绝大多数情况下，快速排序能在 O(nlogn) 的时间复杂度下运行。
- 缓存使用效率高：在执行哨兵划分操作时，系统可将整个子数组加载到缓存，因此访问元素的效率较高。而像“堆排序”这类算法需要跳跃式访问元素，从而缺乏这一特性。
- 复杂度的常数系数低：在上述三种算法中，快速排序的比较、赋值、交换等操作的总数量最少。这与“插入排序”比“冒泡排序”更快的原因类似。
基准数优化
快速排序在某些输入下的时间效率可能降低。举一个极端例子，假设输入数组是完全倒序的，由于我们选择最左端元素作为基准数，那么在哨兵划分完成后，基准数被交换至数组最右端，导致左子数组长度为 n−1、右子数组长度为 0 。如此递归下去，每轮哨兵划分后的右子数组长度都为 0 ，分治策略失效，快速排序退化为“冒泡排序”。为了尽量避免这种情况发生，可以优化哨兵划分中的基准数的选取策略。可以在数组中选取三个候选元素（通常为数组的首、尾、中点元素），并将这三个候选元素的中位数作为基准数。这样一来，基准数“既不太小也不太大”的概率将大幅提升。当然，还可以选取更多候选元素，以进一步提高算法的稳健性。采用这种方法后，时间复杂度劣化至 O(n^2) 的概率大大降低。
Python：
def median_three(self, nums: list[int], left: int, mid: int, right: int) -> int: """选取三个元素的中位数""" # 此处使用异或运算来简化代码 # 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1 if (nums[left] < nums[mid]) ^ (nums[left] < nums[right]): return left elif (nums[mid] < nums[left]) ^ (nums[mid] < nums[right]): return mid return right def partition(self, nums: list[int], left: int, right: int) -> int: """哨兵划分（三数取中值）""" # 以 nums[left] 作为基准数 med = self.median_three(nums, left, (left + right) // 2, right) # 将中位数交换至数组最左端 nums[left], nums[med] = nums[med], nums[left] # 以 nums[left] 作为基准数 i, j = left, right while i < j: while i < j and nums[j] >= nums[left]: j -= 1 # 从右向左找首个小于基准数的元素 while i < j and nums[i] <= nums[left]: i += 1 # 从左向右找首个大于基准数的元素 # 元素交换 nums[i], nums[j] = nums[j], nums[i] # 将基准数交换至两子数组的分界线 nums[i], nums[left] = nums[left], nums[i] return i # 返回基准数的索引- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
Go：
/* 选取三个元素的中位数 */ func (q *quickSortMedian) medianThree(nums []int, left, mid, right int) int { // 此处使用异或运算来简化代码（!= 在这里起到异或的作用） // 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1 if (nums[left] < nums[mid]) != (nums[left] < nums[right]) { return left } else if (nums[mid] < nums[left]) != (nums[mid] < nums[right]) { return mid } return right } /* 哨兵划分（三数取中值）*/ func (q *quickSortMedian) partition(nums []int, left, right int) int { // 以 nums[left] 作为基准数 med := q.medianThree(nums, left, (left+right)/2, right) // 将中位数交换至数组最左端 nums[left], nums[med] = nums[med], nums[left] // 以 nums[left] 作为基准数 i, j := left, right for i < j { for i < j && nums[j] >= nums[left] { j-- //从右向左找首个小于基准数的元素 } for i < j && nums[i] <= nums[left] { i++ //从左向右找首个大于基准数的元素 } //元素交换 nums[i], nums[j] = nums[j], nums[i] } //将基准数交换至两子数组的分界线 nums[i], nums[left] = nums[left], nums[i] return i //返回基准数的索引 }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
尾递归优化
在某些输入下，快速排序可能占用空间较多。以完全倒序的输入数组为例，由于每轮哨兵划分后右子数组长度为 0 ，递归树的高度会达到 n−1 ，此时需要占用 O(n) 大小的栈帧空间。为了防止栈帧空间的累积，我们可以在每轮哨兵排序完成后，比较两个子数组的长度，仅对较短的子数组进行递归。由于较短子数组的长度不会超过 n/2 ，因此这种方法能确保递归深度不超过 logn ，从而将最差空间复杂度优化至 O(logn) 。
Pyhton：
def quick_sort(self, nums: list[int], left: int, right: int): """快速排序（尾递归优化）""" # 子数组长度为 1 时终止 while left < right: # 哨兵划分操作 pivot = self.partition(nums, left, right) # 对两个子数组中较短的那个执行快排 if pivot - left < right - pivot: self.quick_sort(nums, left, pivot - 1) # 递归排序左子数组 left = pivot + 1 # 剩余未排序区间为 [pivot + 1, right] else: self.quick_sort(nums, pivot + 1, right) # 递归排序右子数组 right = pivot - 1 # 剩余未排序区间为 [left, pivot - 1]- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
Go:
/* 快速排序（尾递归优化）*/ func (q *quickSortTailCall) quickSort(nums []int, left, right int) { // 子数组长度为 1 时终止 for left < right { // 哨兵划分操作 pivot := q.partition(nums, left, right) // 对两个子数组中较短的那个执行快排 if pivot-left < right-pivot { q.quickSort(nums, left, pivot-1) // 递归排序左子数组 left = pivot + 1 // 剩余未排序区间为 [pivot + 1, right] } else { q.quickSort(nums, pivot+1, right) // 递归排序右子数组 right = pivot - 1 // 剩余未排序区间为 [left, pivot - 1] } } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
归并排序
归并排序是一种基于分治策略的排序算法，包含“划分”和“合并”阶段。
- 划分阶段：通过递归不断地将数组从中点处分开，将长数组的排序问题转换为短数组的排序问题。
- 合并阶段：当子数组长度为 1 时终止划分，开始合并，持续地将左右两个较短的有序数组合并为一个较长的有序数组，直至结束。
“划分阶段”从顶至底递归地将数组从中点切分为两个子数组。
- 计算数组中点
mid，递归划分左子数组（区间[left, mid]）和右子数组（区间[mid + 1, right]）。 - 递归执行步骤
1.，直至子数组区间长度为 1 时，终止递归划分。
“合并阶段”从底至顶地将左子数组和右子数组合并为一个有序数组。需要注意的是，从长度为 1 的子数组开始合并，合并阶段中的每个子数组都是有序的。归并排序与二叉树后序遍历的递归顺序是一致的。
- 后序遍历：先递归左子树，再递归右子树，最后处理根节点。
- 归并排序：先递归左子数组，再递归右子数组，最后处理合并。
Python：
def merge(nums: list[int], left: int, mid: int, right: int): """合并左子数组和右子数组""" # 左子数组区间 [left, mid] # 右子数组区间 [mid + 1, right] # 初始化辅助数组 tmp = list(nums[left : right + 1]) # 左子数组的起始索引和结束索引 left_start = 0 left_end = mid - left # 右子数组的起始索引和结束索引 right_start = mid + 1 - left right_end = right - left # i, j 分别指向左子数组、右子数组的首元素 i = left_start j = right_start # 通过覆盖原数组 nums 来合并左子数组和右子数组 for k in range(left, right + 1): # 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++ if i > left_end: nums[k] = tmp[j] j += 1 # 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++ elif j > right_end or tmp[i] <= tmp[j]: nums[k] = tmp[i] i += 1 # 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++ else: nums[k] = tmp[j] j += 1 def merge_sort(nums: list[int], left: int, right: int): """归并排序""" # 终止条件 if left >= right: return # 当子数组长度为 1 时终止递归 # 划分阶段 mid = (left + right) // 2 # 计算中点 merge_sort(nums, left, mid) # 递归左子数组 merge_sort(nums, mid + 1, right) # 递归右子数组 # 合并阶段 merge(nums, left, mid, right)- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
Go：
/* 合并左子数组和右子数组 */ // 左子数组区间 [left, mid] // 右子数组区间 [mid + 1, right] func merge(nums []int, left, mid, right int) { // 初始化辅助数组 借助 copy 模块 tmp := make([]int, right-left+1) for i := left; i <= right; i++ { tmp[i-left] = nums[i] } // 左子数组的起始索引和结束索引 leftStart, leftEnd := left-left, mid-left // 右子数组的起始索引和结束索引 rightStart, rightEnd := mid+1-left, right-left // i, j 分别指向左子数组、右子数组的首元素 i, j := leftStart, rightStart // 通过覆盖原数组 nums 来合并左子数组和右子数组 for k := left; k <= right; k++ { // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++ if i > leftEnd { nums[k] = tmp[j] j++ // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++ } else if j > rightEnd || tmp[i] <= tmp[j] { nums[k] = tmp[i] i++ // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++ } else { nums[k] = tmp[j] j++ } } } /* 归并排序 */ func mergeSort(nums []int, left, right int) { // 终止条件 if left >= right { return } // 划分阶段 mid := (left + right) / 2 mergeSort(nums, left, mid) mergeSort(nums, mid+1, right) // 合并阶段 merge(nums, left, mid, right) }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
实现合并函数
merge()存在以下难点。- 需要特别注意各个变量的含义。
nums的待合并区间为[left, right]，但由于tmp仅复制了nums该区间的元素，因此tmp对应区间为[0, right - left]。 - 在比较
tmp[i]和tmp[j]的大小时，还需考虑子数组遍历完成后的索引越界问题，即i > leftEnd和j > rightEnd的情况。索引越界的优先级是最高的，如果左子数组已经被合并完了，那么不需要继续比较，直接合并右子数组元素即可。
算法特性：
- 时间复杂度 O(nlogn)、非自适应排序：划分产生高度为 logn 的递归树，每层合并的总操作数量为 n ，因此总体时间复杂度为 O(nlogn) 。
- 空间复杂度 O(n)、非原地排序：递归深度为 logn ，使用 O(logn) 大小的栈帧空间。合并操作需要借助辅助数组实现，使用 O(n) 大小的额外空间。
- 稳定排序：在合并过程中，相等元素的次序保持不变。
堆排序
堆排序是一种基于堆数据结构实现的高效排序算法。可以利用“建堆操作”和“元素出堆操作”实现堆排序。
- 输入数组并建立小顶堆，此时最小元素位于堆顶。
- 不断执行出堆操作，依次记录出堆元素，即可得到从小到大排序的序列。
设数组的长度为 n：
- 输入数组并建立大顶堆。完成后，最大元素位于堆顶。
- 将堆顶元素（第一个元素）与堆底元素（最后一个元素）交换。完成交换后，堆的长度减 1 ，已排序元素数量加 1 。
- 从堆顶元素开始，从顶到底执行堆化操作（Sift Down）。完成堆化后，堆的性质得到修复。
- 循环执行第
2.和3.步。循环 n−1 轮后，即可完成数组排序。
Python：
def sift_down(nums: list[int], n: int, i: int): """堆的长度为 n ，从节点 i 开始，从顶至底堆化""" while True: # 判断节点 i, l, r 中值最大的节点，记为 ma l = 2 * i + 1 r = 2 * i + 2 ma = i if l < n and nums[l] > nums[ma]: ma = l if r < n and nums[r] > nums[ma]: ma = r # 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if ma == i: break # 交换两节点 nums[i], nums[ma] = nums[ma], nums[i] # 循环向下堆化 i = ma def heap_sort(nums: list[int]): """堆排序""" # 建堆操作：堆化除叶节点以外的其他所有节点 for i in range(len(nums) // 2 - 1, -1, -1): sift_down(nums, len(nums), i) # 从堆中提取最大元素，循环 n-1 轮 for i in range(len(nums) - 1, 0, -1): # 交换根节点与最右叶节点（即交换首元素与尾元素） nums[0], nums[i] = nums[i], nums[0] # 以根节点为起点，从顶至底进行堆化 sift_down(nums, i, 0)- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
Go：
/* 堆的长度为 n ，从节点 i 开始，从顶至底堆化 */ func siftDown(nums *[]int, n, i int) { for true { // 判断节点 i, l, r 中值最大的节点，记为 ma l := 2*i + 1 r := 2*i + 2 ma := i if l < n && (*nums)[l] > (*nums)[ma] { ma = l } if r < n && (*nums)[r] > (*nums)[ma] { ma = r } // 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出 if ma == i { break } // 交换两节点 (*nums)[i], (*nums)[ma] = (*nums)[ma], (*nums)[i] // 循环向下堆化 i = ma } } /* 堆排序 */ func heapSort(nums *[]int) { // 建堆操作：堆化除叶节点以外的其他所有节点 for i := len(*nums)/2 - 1; i >= 0; i-- { siftDown(nums, len(*nums), i) } // 从堆中提取最大元素，循环 n-1 轮 for i := len(*nums) - 1; i > 0; i-- { // 交换根节点与最右叶节点（即交换首元素与尾元素） (*nums)[0], (*nums)[i] = (*nums)[i], (*nums)[0] // 以根节点为起点，从顶至底进行堆化 siftDown(nums, i, 0) } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 时间复杂度 O(nlogn)、非自适应排序：建堆操作使用 O(n) 时间。从堆中提取最大元素的时间复杂度为 O(logn) ，共循环 n−1 轮。
- 空间复杂度 O(1)、原地排序：几个指针变量使用 O(1) 空间。元素交换和堆化操作都是在原数组上进行的。
- 非稳定排序：在交换堆顶元素和堆底元素时，相等元素的相对位置可能发生变化。
桶排序
桶排序是分治策略的一个典型应用。它通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中；然后，在每个桶内部分别执行排序；最终按照桶的顺序将所有数据合并。考虑一个长度为 n 的数组，元素是范围 [0,1) 的浮点数。桶排序的流程如下图所示。
- 初始化 k 个桶，将 n 个元素分配到 k 个桶中。
- 对每个桶分别执行排序。
- 按照桶的从小到大的顺序，合并结果。
Python：
def bucket_sort(nums: list[float]): """桶排序""" # 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素 k = len(nums) // 2 buckets = [[] for _ in range(k)] # 1. 将数组元素分配到各个桶中 for num in nums: # 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1] i = int(num * k) # 将 num 添加进桶 i buckets[i].append(num) # 2. 对各个桶执行排序 for bucket in buckets: # 使用内置排序函数，也可以替换成其他排序算法 bucket.sort() # 3. 遍历桶合并结果 i = 0 for bucket in buckets: for num in bucket: nums[i] = num i += 1- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
Go：
/* 桶排序 */ func bucketSort(nums []float64) { // 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素 k := len(nums) / 2 buckets := make([][]float64, k) for i := 0; i < k; i++ { buckets[i] = make([]float64, 0) } // 1. 将数组元素分配到各个桶中 for _, num := range nums { // 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1] i := int(num * float64(k)) // 将 num 添加进桶 i buckets[i] = append(buckets[i], num) } // 2. 对各个桶执行排序 for i := 0; i < k; i++ { // 使用内置切片排序函数，也可以替换成其他排序算法 sort.Float64s(buckets[i]) } // 3. 遍历桶合并结果 i := 0 for _, bucket := range buckets { for _, num := range bucket { nums[i] = num i++ } } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
桶排序适用于处理体量很大的数据。例如，输入数据包含 100 万个元素，由于空间限制，系统内存无法一次性加载所有数据。此时，可以将数据分成 1000 个桶，然后分别对每个桶进行排序，最后将结果合并。
- 时间复杂度 O(n+k) ：假设元素在各个桶内平均分布，那么每个桶内的元素数量为 n/k 。假设排序单个桶使用 O(n/k logn/k) 时间，则排序所有桶使用 O(n logn/k) 时间。当桶数量 k 比较大时，时间复杂度则趋向于 O(n) 。合并结果时需要遍历所有桶和元素，花费 O(n+k) 时间。
- 自适应排序：在最坏情况下，所有数据被分配到一个桶中，且排序该桶使用 O(n^2) 时间。
- 空间复杂度 O(n+k)、非原地排序：需要借助 k 个桶和总共 n 个元素的额外空间。
- 桶排序是否稳定取决于排序桶内元素的算法是否稳定。
桶排序的时间复杂度理论上可以达到 O(n) ，关键在于将元素均匀分配到各个桶中，因为实际数据往往不是均匀分布的。例如想要将淘宝上的所有商品按价格范围平均分配到 10 个桶中，但商品价格分布不均，低于 100 元的非常多，高于 1000 元的非常少。若将价格区间平均划分为 10 份，各个桶中的商品数量差距会非常大。为实现平均分配，可以先设定一个大致的分界线，将数据粗略地分到 3 个桶中。分配完毕后，再将商品较多的桶继续划分为 3 个桶，直至所有桶中的元素数量大致相等。如下图所示，这种方法本质上是创建一个递归树，目标是让叶节点的值尽可能平均。当然，不一定要每轮将数据划分为 3 个桶，具体划分方式可根据数据特点灵活选择。
如果提前知道商品价格的概率分布，则可以根据数据概率分布设置每个桶的价格分界线。值得注意的是，数据分布并不一定需要特意统计，也可以根据数据特点采用某种概率模型进行近似。假设商品价格服从正态分布，这样就可以合理地设定价格区间，从而将商品平均分配到各个桶中。
计数排序
计数排序通过统计元素数量来实现排序，通常应用于整数数组。给定一个长度为 n 的数组
nums，其中的元素都是“非负整数”。- 遍历数组，找出数组中的最大数字，记为 m ，然后创建一个长度为 m+1 的辅助数组
counter。 - 借助
counter统计nums中各数字的出现次数，其中counter[num]对应数字num的出现次数。统计方法很简单，只需遍历nums（设当前数字为num），每轮将counter[num]增加 1 即可。 - 由于
counter的各个索引天然有序，因此相当于所有数字已经被排序好了。接下来，我们遍历counter，根据各数字的出现次数，将它们按从小到大的顺序填入nums即可。
Python：
def counting_sort_naive(nums: list[int]): """计数排序""" # 简单实现，无法用于排序对象 # 1. 统计数组最大元素 m m = 0 for num in nums: m = max(m, num) # 2. 统计各数字的出现次数 # counter[num] 代表 num 的出现次数 counter = [0] * (m + 1) for num in nums: counter[num] += 1 # 3. 遍历 counter ，将各元素填入原数组 nums i = 0 for num in range(m + 1): for _ in range(counter[num]): nums[i] = num i += 1- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
Go：
/* 计数排序 */ // 简单实现，无法用于排序对象 func countingSortNaive(nums []int) { // 1. 统计数组最大元素 m m := 0 for _, num := range nums { if num > m { m = num } } // 2. 统计各数字的出现次数 // counter[num] 代表 num 的出现次数 counter := make([]int, m+1) for _, num := range nums { counter[num]++ } // 3. 遍历 counter ，将各元素填入原数组 nums for i, num := 0, 0; num < m+1; num++ { for j := 0; j < counter[num]; j++ { nums[i] = num i++ } } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
从桶排序的角度看，我们可以将计数排序中的计数数组
counter的每个索引视为一个桶，将统计数量的过程看作是将各个元素分配到对应的桶中。本质上，计数排序是桶排序在整型数据下的一个特例。- 时间复杂度 O(n+m) ：涉及遍历
nums和遍历counter，都使用线性时间。一般情况下 n≫m ，时间复杂度趋于 O(n) 。 - 空间复杂度 O(n+m)、非原地排序：借助了长度分别为 n 和 m 的数组
res和counter。
使用计数排序的前置条件相对较为严格。
-
计数排序只适用于非负整数。若想要将其用于其他类型的数据，需要确保这些数据可以被转换为非负整数，并且在转换过程中不能改变各个元素之间的相对大小关系。例如，对于包含负数的整数数组，可以先给所有数字加上一个常数，将全部数字转化为正数，排序完成后再转换回去即可。
-
计数排序适用于数据量大但数据范围较小的情况。比如，在上述示例中 m 不能太大，否则会占用过多空间。而当 n≪m 时，计数排序使用 O(m) 时间，可能比 O(nlogn) 的排序算法还要慢。
基数排序
基数排序的核心思想与计数排序一致，也通过统计个数来实现排序。在此基础上，基数排序利用数字各位之间的递进关系，依次对每一位进行排序，从而得到最终的排序结果。
以学号数据为例，假设数字的最低位是第 1 位，最高位是第 8 位，基数排序的流程如下图所示。
- 初始化位数 k=1 。
- 对学号的第 k 位执行“计数排序”。完成后，数据会根据第 k 位从小到大排序。
- 将 k 增加 1 ，然后返回步骤
2.继续迭代，直到所有位都排序完成后结束。
由于数字的高位优先级高于低位，我们应该先排序低位再排序高位。
对于一个 d 进制的数字 x ，要获取其第 k 位 xₖ，可以使用以下计算公式：
其中 ⌊a⌋ 表示对浮点数 a 向下取整，而 mod d 表示对 d 取余。对于学号数据，d=10 且 k∈[1,8] 。
此外需要小幅改动计数排序代码，使之可以根据数字的第 k 位进行排序。
Python：
def digit(num: int, exp: int) -> int: """获取元素 num 的第 k 位，其中 exp = 10^(k-1)""" # 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算 return (num // exp) % 10 def counting_sort_digit(nums: list[int], exp: int): """计数排序（根据 nums 第 k 位排序）""" # 十进制的位范围为 0~9 ，因此需要长度为 10 的桶 counter = [0] * 10 n = len(nums) # 统计 0~9 各数字的出现次数 for i in range(n): d = digit(nums[i], exp) # 获取 nums[i] 第 k 位，记为 d counter[d] += 1 # 统计数字 d 的出现次数 # 求前缀和，将“出现个数”转换为“数组索引” for i in range(1, 10): counter[i] += counter[i - 1] # 倒序遍历，根据桶内统计结果，将各元素填入 res res = [0] * n for i in range(n - 1, -1, -1): d = digit(nums[i], exp) j = counter[d] - 1 # 获取 d 在数组中的索引 j res[j] = nums[i] # 将当前元素填入索引 j counter[d] -= 1 # 将 d 的数量减 1 # 使用结果覆盖原数组 nums for i in range(n): nums[i] = res[i] def radix_sort(nums: list[int]): """基数排序""" # 获取数组的最大元素，用于判断最大位数 m = max(nums) # 按照从低位到高位的顺序遍历 exp = 1 while exp <= m: # 对数组元素的第 k 位执行计数排序 # k = 1 -> exp = 1 # k = 2 -> exp = 10 # 即 exp = 10^(k-1) counting_sort_digit(nums, exp) exp *= 10- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
Go：
/* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */ func digit(num, exp int) int { // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算 return (num / exp) % 10 } /* 计数排序（根据 nums 第 k 位排序） */ func countingSortDigit(nums []int, exp int) { // 十进制的位范围为 0~9 ，因此需要长度为 10 的桶 counter := make([]int, 10) n := len(nums) // 统计 0~9 各数字的出现次数 for i := 0; i < n; i++ { d := digit(nums[i], exp) // 获取 nums[i] 第 k 位，记为 d counter[d]++ // 统计数字 d 的出现次数 } // 求前缀和，将“出现个数”转换为“数组索引” for i := 1; i < 10; i++ { counter[i] += counter[i-1] } // 倒序遍历，根据桶内统计结果，将各元素填入 res res := make([]int, n) for i := n - 1; i >= 0; i-- { d := digit(nums[i], exp) j := counter[d] - 1 // 获取 d 在数组中的索引 j res[j] = nums[i] // 将当前元素填入索引 j counter[d]-- // 将 d 的数量减 1 } // 使用结果覆盖原数组 nums for i := 0; i < n; i++ { nums[i] = res[i] } } /* 基数排序 */ func radixSort(nums []int) { // 获取数组的最大元素，用于判断最大位数 max := math.MinInt for _, num := range nums { if num > max { max = num } } // 按照从低位到高位的顺序遍历 for exp := 1; max >= exp; exp *= 10 { // 对数组元素的第 k 位执行计数排序 // k = 1 -> exp = 1 // k = 2 -> exp = 10 // 即 exp = 10^(k-1) countingSortDigit(nums, exp) } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
相较于计数排序，基数排序适用于数值范围较大的情况，但前提是数据必须可以表示为固定位数的格式，且位数不能过大。例如，浮点数不适合使用基数排序，因为其位数 k 过大，可能导致时间复杂度 O(nk)≫O(n^2) 。
- 时间复杂度 O(nk)：设数据量为 n、数据为 d 进制、最大位数为 k ，则对某一位执行计数排序使用 O(n+d) 时间，排序所有 k 位使用 O((n+d)k) 时间。通常情况下，d 和 k 都相对较小，时间复杂度趋向 O(n) 。
- 空间复杂度 O(n+d)、非原地排序：与计数排序相同，基数排序需要借助长度为 n 和 d 的数组
res和counter。 - 稳定排序：与计数排序相同。
排序算法对比
References：https://www.hello-algo.com/chapter_sorting/
-
-
相关阅读:
我找回了我喜欢的Github Old Feed
一文看懂推荐系统：排序09：Field-aware Factorization Machines（FFM），从FM改进来的，效果不咋地
排序算法 堆排序
【2022-11-28】Docker部署搭建Gitlab
MATLAB算法实战应用案例精讲-【图像处理】机器视觉（补充篇）
设计模式-原型模式
【OpenCV 例程200篇】236. 特征提取之主成分分析（OpenCV）
Springboot+vue微信小程序的学生选课系统#毕业设计
PHP7的新特性
JavaScript
- 原文地址：https://blog.csdn.net/m0_63230155/article/details/132952076
