六大排序算法的精髓，轻松征服排序难题！

2023-06-23 00:05:26

排序算法：信息世界里的秩序之舞

排序算法详解

排序算法是计算机科学中不可或缺的一部分，它们负责将数据集合整理成有序序列。这些算法就像巧妙的舞者，将杂乱无章的元素编织成优美而有条理的图案。

插入排序：简单高效的卡片整理

想象一下一叠杂乱无章的卡片，插入排序就像一位细致入微的园丁，将它们一张一张插入到正确的顺序中。它从第二张卡片开始，依次与之前的卡片比较，将较小的卡片插入到合适的位置。这个过程持续进行，直到所有卡片都井然有序。

代码示例：

def insertion_sort(arr):
  for i in range(1, len(arr)):
    key = arr[i]
    j = i - 1
    while j >= 0 and key < arr[j]:
      arr[j + 1] = arr[j]
      j -= 1
    arr[j + 1] = key

希尔排序：分组优化，效率提升

希尔排序在插入排序的基础上更进一步，它将数据分组，然后对每一组进行插入排序。随着分组间隔的缩小，数据逐渐变得更加有序，最后完成整体排序。

代码示例：

def shell_sort(arr):
  gap = len(arr) // 2
  while gap > 0:
    for i in range(gap, len(arr)):
      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

冒泡排序：耐心交换，终成有序

冒泡排序就像一位耐心十足的厨师，它一遍又一遍地比较相邻的元素，如果顺序不正确，就交换它们的顺序。这个过程反复进行，直到没有更多的交换需要进行，数据便整齐有序。

代码示例：

def bubble_sort(arr):
  for i in range(len(arr) - 1):
    swapped = False
    for j in range(0, len(arr) - i - 1):
      if arr[j] > arr[j + 1]:
        arr[j], arr[j + 1] = arr[j + 1], arr[j]
        swapped = True
    if not swapped:
      break

快速排序：分而治之，效率倍增

快速排序采用分而治之的方法，将数据划分为两个部分：比某个基准值小的元素和比基准值大的元素。然后对这两个部分分别进行排序，最后将它们合并得到最终结果。

代码示例：

def quick_sort(arr):
  if len(arr) <= 1:
    return arr
  pivot = arr[len(arr) // 2]
  left = [x for x in arr if x < pivot]
  middle = [x for x in arr if x == pivot]
  right = [x for x in arr if x > pivot]
  return quick_sort(left) + middle + quick_sort(right)

选择排序：寻找最优，逐次排序

选择排序通过逐一寻找最小（或最大）元素并将其放置在正确的位置，来实现排序。这个过程重复进行，直到所有元素都按顺序排列。

代码示例：

def selection_sort(arr):
  for i in range(len(arr)):
    min_idx = i
    for j in range(i + 1, len(arr)):
      if arr[j] < arr[min_idx]:
        min_idx = j
    arr[i], arr[min_idx] = arr[min_idx], arr[i]

归并排序：分治合并，稳定有序

归并排序是一种稳定的排序算法，这意味着具有相同值的元素在排序后仍保持其相对顺序。它采用分治合并的方式，将数据分成两半，分别排序，然后将排序后的结果合并为一个有序序列。

代码示例：

def merge_sort(arr):
  if len(arr) <= 1:
    return arr
  mid = len(arr) // 2
  left_half = merge_sort(arr[:mid])
  right_half = merge_sort(arr[mid:])
  return merge(left_half, right_half)

def merge(left, right):
  merged = []
  left_idx = 0
  right_idx = 0
  while left_idx < len(left) and right_idx < len(right):
    if left[left_idx] <= right[right_idx]:
      merged.append(left[left_idx])
      left_idx += 1
    else:
      merged.append(right[right_idx])
      right_idx += 1
  merged.extend(left[left_idx:])
  merged.extend(right[right_idx:])
  return merged

性能比较

不同排序算法的性能各不相同，它们根据数据规模、数据分布和所需时间复杂度而有所不同。

算法	时间复杂度	空间复杂度	稳定性
插入排序	O(n^2)	O(1)	是
希尔排序	O(n^1.3)	O(1)	否
冒泡排序	O(n^2)	O(1)	是
快速排序	O(n log n)	O(log n)	否
选择排序	O(n^2)	O(1)	否
归并排序	O(n log n)	O(n)	是