十个常用排序算法的原理及python模板
这里写目录标题
- 冒泡排序 Bubble Sort
- 快速排序 Quick Sort
- 插入排序 Insertion Sort
- 希尔排序 Shell Sort
- 选择排序 Select Sort
- 堆排序 Heap Sort
- 归并排序 Merge Sort
- 计数排序 Counting Sort
- 基数排序（Radix Sort）
- 桶排序（Bucket Sort）
冒泡排序 Bubble Sort
原理：从第一个元素开始，将相邻的两个元素进行比较，如果前一个元素大于后一个元素就将它们交换，一轮下来最大的元素就会被交换到最后，再对前面的元素进行相同的操作，直到全部排序完成。
模板：
def bubble_sort(nums):
n = len(nums)
for i in range(n):
for j in range(0, n - i - 1): #表示每一轮循环需要比较的元素数量，每一轮结束后要将已排序的元素排除在外。
if nums[j] > nums[j + 1]:
nums[j], nums[j + 1] = nums[j + 1], nums[j]
return nums
快速排序 Quick Sort
原理：选择一个枢轴元素，将序列分为左右两部分，左边的元素都小于枢轴元素，右边的元素都大于它，然后对左右两部分分别进行相同的操作，直到全部排序完成。
模板：
def quick_sort(nums):
if len(nums) <= 1:
return nums
pivot = nums[0] #pivot表示枢轴元素
left_nums = [x for x in nums[1:] if x < pivot]
right_nums = [x for x in nums[1:] if x >= pivot]
return quick_sort(left_nums) + [pivot] + quick_sort(right_nums)
插入排序 Insertion Sort
原理：将未排序序列中的第一个元素插入到已排序序列中合适的位置，对于未排序序列中的其他元素进行相同的操作，直到全部排序完成。
模板：
def insertion_sort(nums):
n = len(nums)
for i in range(1, n):
j = i
while j > 0 and nums[j - 1] > nums[j]:
nums[j], nums[j - 1] = nums[j - 1], nums[j]
j -= 1
return nums
希尔排序 Shell Sort
原理：希尔排序，也称缩小增量排序，是插入排序的一种高效改进式版本。它的思想是将数组分成若干个子序列，对每个子序列进行插入排序，经过若干轮排序后，整个序列变成有序。与插入排序不同的是，希尔排序是对元素间隔固定的多个子序列分别进行插入排序，随着排序轮数的增加，子序列的长度逐渐缩小，最后变成一个整体有序的序列。
希尔排序通过减小项间距，使得一些逆序对提前得到了交换，从而加快排序的速度。这也是希尔排序高效的主要原因。
模板：
def shell_sort(arr):
n=len(arr)
gap=n//2
while gap>0:
for i in range(gap,n):
j=i
while j>=gap and arr[j]<arr[j-gap]:
arr[j],arr[j-gap]=arr[j-gap],arr[j]
j-=gap
gap//=2
return arr
选择排序 Select Sort
原理：从第一个元素开始，找到剩余元素中最小的元素，将它与第一个元素交换位置，然后从第二个元素开始重复这个过程，直到全部排序完成。
模板：
def selection_sort(nums):
n = len(nums)
for i in range(n - 1):
min_index = i
for j in range(i + 1, n):
if nums[j] < nums[min_index]:
min_index = j
if min_index != i:
nums[i], nums[min_index] = nums[min_index], nums[i]
return nums
注释：
min_index表示当前未排序元素中最小值的下标。
if nums[j] < nums[min_index]:表示如果找到了比当前最小值还要小的值，就更新min_index。
if min_index != i:表示如果min_index没有变化，就意味着当前元素已经是未排序元素中最小的，不需要交换。
堆排序 Heap Sort
原理：堆排序是一种选择排序。它是借助堆这种数据结构来完成的。堆分为小根堆和大根堆，大根堆就是堆顶是最大值的堆，小根堆就是堆顶是最小值的堆。堆排序主要分为两个步骤：
- 建立堆：将数组建立成大根堆或小根堆。
- 排序：将堆顶元素与堆底元素交换，然后删除堆底元素并进行堆调整，重复此过程直到堆中只有一个元素。
模板：
def heapify(a, n, i): # 将小的节点向下交换，使之成为一棵大根堆
largest = i
l = 2 * i + 1 # 左子节点
r = 2 * i + 2 # 右子节点
# 找到三个节点中的最大值
if l < n and a[l] > a[largest]:
largest = l
if r < n and a[r] > a[largest]:
largest = r
# 如果最大节点不是当前节点，就交换它们的位置，并递归地调用 heapify
if largest != i:
a[i], a[largest] = a[largest], a[i]
heapify(a, n, largest)
def heap_sort(a):
n = len(a)
# 构建二叉堆
for i in range(n // 2 - 1, -1, -1):
heapify(a, n, i)
# 针对二叉树的每个节点，将根节点与末尾节点交换，末尾节点被"排序"，然后 heapify 重新平衡行，从而保证根节点的最大值
for i in range(n - 1, 0, -1):
a[i], a[0] = a[0], a[i]
heapify(a, i, 0)
return a
使用 heapq 模块内置函数实现堆排序的 Python 模板：
import heapq
def heap_sort(arr):
# 将列表转换为堆
heapq.heapify(arr)
# 依次弹出堆中元素，即可获得有序序列
result = []
while arr:
result.append(heapq.heappop(arr))
return result
归并排序 Merge Sort
原理：将序列拆分成每个只有一个元素的子序列，然后对这些子序列进行两两归并，直到所有子序列都归并成一个有序序列。
模板：
def merge_sort(nums):
if len(nums) <= 1:
return nums
mid = len(nums) // 2
left_nums = nums[:mid]
right_nums = nums[mid:]
return merge(merge_sort(left_nums), merge_sort(right_nums)) # 先对左右两个子序列进行排序，然后进行归并
def merge(left_nums, right_nums):
result = []
i, j = 0, 0
while i < len(left_nums) and j < len(right_nums):
if left_nums[i] < right_nums[j]:
result.append(left_nums[i])
i += 1
else:
result.append(right_nums[j])
j += 1
result += left_nums[i:]
result += right_nums[j:]
return result
计数排序 Counting Sort
原理：计数排序是一种非比较排序算法，它的主要思想是对于给定的一组元素，确定每个元素在序列中出现的个数，进而推算出每个元素在最终有序序列中所处的位置。要求输入的数据必须是有确定范围的整数（如内部所有元素均在 0~K 的范围内），并且是离散的元素。
在计数排序中，我们利用待排序数列中的最大值和最小值来确定统计数组的长度，然后逐个遍历计算出待排序序列中每个元素出现的次数。接下来，我们依据统计数组中记录的元素出现次数，从小到大或从大到小地做一个累加，目的是确定待排序元素在有序序列中的索引位置。最后，我们对待排序序列进行遍历，按照有序序列的索引位置将待排序元素放入其应该在的位置，从而得到有序的序列。
适应场景：要求输入的数据必须是有确定范围的整数，适合于最大值和最小值的差值不是很大的情况，或对时间复杂度要求较高，快排O(nlogn) 解决不了，需要O(n) 或题目明确约束要线性时间内运行的场景。基本思想就是把数组元素作为数组的下标，然后用一个临时数组统计该元素出现的次数，例如 temp[i] = m, 表示元素 i 一共出现了 m 次。最后再把临时数组统计的数据从小到大汇总起来。
：LeetCode计数排序，274，561， 912，1122
模板：
def counting_sort(arr):
size = len(arr)
if size<2: # 处理长度为0或1的情况
return arr
# 找到序列中的最大值和最小值，以确定计数数组(c)的长度
max_val = max(arr)
min_val = min(arr)
# 统计数组c用于记录元素i出现的次数
c = [0] * (max_val - min_val + 1)
for i in arr:
c[i - min_val] += 1
# 累加计数数组c并更新这些元素的顺序
for i in range(1, len(c)):
c[i] = c[i - 1] + c[i]
# 创建一个临时数组，用于存储排序后的结果
ans = [0] * size
for i in reversed(arr):
ans[c[i - min_val] - 1] = i
c[i - min_val] -= 1
return ans
基数排序（Radix Sort）
原理：基数排序是按照数字位数从低到高依次对待排序数字进行排序，最终可以获得有序序列。具体实现中，每次操作时将待排序序列按照指定位数进行分桶，然后按照顺序将桶中的数字输出，重复该过程直到全部数字排序完成。
以下是基数排序的实现模板：
def radix_sort(nums):
# 找到待排序序列中最大的数字
max_digit = 0
for num in nums:
max_digit = max(max_digit, len(str(num)))
# 从个位到最高位进行排序
for i in range(max_digit):
# 初始化10个桶
bucket = [[] for _ in range(10)]
# 将每个数字分配到对应的桶中
for num in nums:
digit = num // (10 ** i) % 10
bucket[digit].append(num)
# 重构待排序序列为已分配的桶中的数字
nums.clear()
for j in range(10):
nums += bucket[j]
return nums
桶排序（Bucket Sort）
原理：桶排序是一种按照区间依次对数字进行排序的算法。具体实现中，首先需要将待排序序列分配到不同的桶中，然后对每一个非空的桶进行排序，并将结果合并到一起。在桶排序中，分配每个数字到桶中的过程可以使用不同的划分函数实现，比如可以按照数字的区间、数字的排名等进行划分。
适应场景：数列取值范围过大，或者不是整数时，如double，就可以用桶排序。桶排序的性能并非绝对稳定，理想情况是桶中的元素分布均匀，元素个数等于桶的个数时，时间复杂度可以达到O(n)；但如果桶内元素的分布极不均衡，极端情况下第一个桶中有n-1个元素，最后一个桶中有1个元素，时间复杂度将退化为O(nlogn) ，还白白浪费空间，创建了许多空桶。
典型题目：LeetCode桶排序，164，220，347，451，692， 908
以下是桶排序的实现模板：
def linear_sort(nums):
max_value = max(nums) # 找到待排序序列中的最大值
bucket = [0] * (max_value + 1) # 初始化一个长度为max_value + 1的桶，用于存放每个数字的出现次数
for num in nums: # 遍历待排序序列，统计每个数字出现的次数
bucket[num] += 1
count = 0 # 记录桶中出现的数字的个数
for i in range(max_value + 1): # 遍历桶，输出排序结果
while bucket[i] > 0:
nums[count] = i
count += 1
bucket[i] -= 1
return nums