揭秘十大排序算法：掌握它们，轻松应对数据洪流！
2023-01-13 23:25:18
十大排序算法：数据分析与处理的利器
前言
在数据驱动的时代，排序算法扮演着至关重要的角色。无论是庞大数据库的管理，还是复杂机器学习模型的训练，对数据进行有效排序都是不可或缺的环节。了解和掌握排序算法可以帮助我们高效地处理海量数据，快速提取所需信息，大幅提升工作效率。
1. 冒泡排序：简单易懂，初学者的垫脚石
冒泡排序是排序算法中最简单的一种。它的工作原理是逐一对相邻元素进行比较，将较大的元素“冒泡”到数组末尾，最终形成有序数组。虽然冒泡排序的时间复杂度较高，但它在理解排序算法的原理方面具有很好的教学价值。
代码示例：
def bubble_sort(arr):
n = len(arr)
for i in range(n-1):
for j in range(n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
2. 选择排序：逐一寻找最小元素，有序插入
选择排序的思想是逐一在剩余的未排序元素中寻找最小元素，然后将其插入到已排序的子数组中。通过这种方式，数组逐渐从小到大有序排列。
代码示例：
def selection_sort(arr):
n = len(arr)
for i in range(n-1):
min_idx = i
for j in range(i+1, n):
if arr[j] < arr[min_idx]:
min_idx = j
arr[i], arr[min_idx] = arr[min_idx], arr[i]
3. 插入排序：有序插入，渐进完善
插入排序采用分治的思想。它将数组分为已排序子数组和未排序子数组，并逐个将未排序子数组中的元素插入到已排序子数组中。插入操作确保了插入后的数组始终保持有序。
代码示例：
def insertion_sort(arr):
n = len(arr)
for i in range(1, n):
key = arr[i]
j = i - 1
while j >= 0 and key < arr[j]:
arr[j+1] = arr[j]
j -= 1
arr[j+1] = key
4. 希尔排序：增量插入，优化性能
希尔排序是对插入排序的优化，它通过引入一个间隔值，以增量方式对数组进行插入排序。这种策略可以减少比较次数，提高算法效率。
代码示例：
def shell_sort(arr):
n = len(arr)
gap = n // 2
while gap > 0:
for i in range(gap, n):
key = arr[i]
j = i
while j >= gap and key < arr[j - gap]:
arr[j] = arr[j - gap]
j -= gap
arr[j] = key
gap //= 2
5. 归并排序：分而治之，高效稳定
归并排序采用分治策略，将数组分为两部分，对每部分进行递归排序，然后将排序后的两部分归并成一个有序数组。归并排序的时间复杂度为O(n log n)，是一种稳定的排序算法。
代码示例：
def merge_sort(arr):
n = len(arr)
if n <= 1:
return arr
mid = n // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
return merge(left, right)
def merge(left, right):
i = 0
j = 0
merged = []
while i < len(left) and j < len(right):
if left[i] <= right[j]:
merged.append(left[i])
i += 1
else:
merged.append(right[j])
j += 1
while i < len(left):
merged.append(left[i])
i += 1
while j < len(right):
merged.append(right[j])
j += 1
return merged
6. 快速排序：随机枢轴，高效不稳定
快速排序也是一种分治算法。它随机选择一个枢轴元素，将数组分为小于枢轴元素和大于枢轴元素的两部分，然后递归地对两部分进行排序。快速排序的时间复杂度为O(n log n)，但它是一种不稳定的排序算法。
代码示例：
def quick_sort(arr):
n = len(arr)
if n <= 1:
return arr
pivot = arr[random.randint(0, n-1)]
left = []
right = []
for i in range(n):
if arr[i] < pivot:
left.append(arr[i])
elif arr[i] > pivot:
right.append(arr[i])
return quick_sort(left) + [pivot] + quick_sort(right)
7. 堆排序：构建最大堆，逐一弹出
堆排序基于堆数据结构。它通过将数组构建成一个最大堆，然后逐一弹出堆顶元素，得到一个有序数组。堆排序的时间复杂度为O(n log n)，是一种不稳定的排序算法。
代码示例：
def heap_sort(arr):
n = len(arr)
build_max_heap(arr)
for i in range(n-1, 0, -1):
arr[0], arr[i] = arr[i], arr[0]
heapify(arr, i)
def build_max_heap(arr):
n = len(arr)
for i in range(n//2 - 1, -1, -1):
heapify(arr, i)
def heapify(arr, i):
left = 2 * i + 1
right = 2 * i + 2
largest = i
if left < len(arr) and arr[left] > arr[largest]:
largest = left
if right < len(arr) and arr[right] > arr[largest]:
largest = right
if largest != i:
arr[i], arr[largest] = arr[largest], arr[i]
heapify(arr, largest)
8. 计数排序：适用于整数排序，空间换时间
计数排序适用于对整数进行排序。它通过统计每个整数出现的次数，然后根据统计结果将整数重新排列，得到一个有序数组。计数排序的时间复杂度为O(n+k)，其中k是整数的最大值。
代码示例：
def counting_sort(arr):
n = len(arr)
max_value = max(arr)
count = [0] * (max_value+1)
for i in range(n):
count[arr[i]] += 1
output = []
for i in range(max_value+1):
while count[i] > 0:
output.append(i)
count[i] -= 1
return output
9. 基数排序：适用于数字排序，稳定且高效
基数排序适用于对数字进行排序。它逐位对数字进行排序，从小数位到整数位依次进行。基数排序的时间复杂度为O(n * k)，其中k是数字的位数。
代码示例：
def radix_sort(arr):
max_value = max(arr)
exp = 1
while max_value // exp > 0:
counting_sort(arr, exp)
exp *= 10
def counting_sort(arr, exp):
n = len(arr)
count = [0] * 10
for i in range(n):
index = arr[i] // exp
count[index % 10] += 1
for i in range(1, 10):
count[i] += count[i - 1]
output = [0] * n
i = n - 1
while i >= 0:
index = arr[i] // exp
output[count[index % 10] - 1] = arr[i]
count[index % 10] -= 1
i -=
