揭秘六大排序算法，玩转数据，高效出击！

2023-07-20 18:25:16

踏入算法世界：解密流行的排序算法

各位算法爱好者们，欢迎来到算法世界的盛宴！今天，我们将深入探索六种最流行的排序算法，从基础到复杂，领略其精妙与魅力。

插入排序：温柔而朴实的教师

想像一位细心的教师，将凌乱的元素一个个插入正确的位置，直到它们全部就位。这就是插入排序的精髓，它以朴实无华的方式，为小规模数据带来高效的排序。

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

选择排序：慧眼独具的侦探

犹如一位慧眼独具的侦探，选择排序善于找到待排序元素中的最小或最大值，并将其放置到正确位置。这种贪心的策略，在小规模数据面前表现优异。

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

冒泡排序：勤劳而简单的清洁工

就像一位勤劳的清洁工，冒泡排序一遍遍地比较相邻元素，将较大的元素向后移动，直到所有元素按顺序排列。它的简单性使其易于理解和实现。

def bubble_sort(arr):
  for i in range(len(arr)):
    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]

快速排序：算法界的闪电侠

快速排序堪称算法界的闪电侠，它就像一位经验丰富的指挥官，将待排序元素一分为二，不断递归地征服子数组，最终将所有元素整齐排列。

def quick_sort(arr, low, high):
  if low < high:
    partition_index = partition(arr, low, high)
    quick_sort(arr, low, partition_index - 1)
    quick_sort(arr, partition_index + 1, high)

def partition(arr, low, high):
  pivot = arr[high]
  i = low - 1
  for j in range(low, high):
    if arr[j] < pivot:
      i += 1
      arr[i], arr[j] = arr[j], arr[i]
  arr[i + 1], arr[high] = arr[high], arr[i + 1]
  return i + 1

归并排序：一丝不苟的数学家

归并排序就像一位一丝不苟的数学家，将待排序元素逐个分解，然后像拼图般将它们重新组合，直至所有元素按顺序排列。

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_index = right_index = 0
  while left_index < len(left) and right_index < len(right):
    if left[left_index] < right[right_index]:
      merged.append(left[left_index])
      left_index += 1
    else:
      merged.append(right[right_index])
      right_index += 1
  merged.extend(left[left_index:])
  merged.extend(right[right_index:])
  return merged

堆排序：严谨而高效的工程师

堆排序犹如一位严谨的工程师，将待排序元素构建成一棵二叉树，然后通过一系列巧妙的操作，将最大或最小元素逐个提取出来，直至所有元素按顺序排列。

def heap_sort(arr):
  build_max_heap(arr)
  for i in range(len(arr) - 1, 0, -1):
    arr[0], arr[i] = arr[i], arr[0]
    heapify(arr, 0, i)

def build_max_heap(arr):
  for i in range(len(arr) // 2 - 1, -1, -1):
    heapify(arr, i, len(arr))

def heapify(arr, i, n):
  largest = i
  left = 2 * i + 1
  right = 2 * i + 2
  if left < n and arr[left] > arr[largest]:
    largest = left
  if right < n and arr[right] > arr[largest]:
    largest = right
  if largest != i:
    arr[i], arr[largest] = arr[largest], arr[i]
    heapify(arr, largest, n)

三向切分排序：足智多谋的将军

三向切分排序是快速排序的优化算法，就像一位足智多谋的将军，将待排序元素分成三部分，然后分别征服，提高了特殊数据结构下的排序效率。

def three_way_partition(arr, low, high):
  pivot = arr[high]
  lt = low - 1
  gt = high
  i = low
  while i < gt:
    if arr[i] < pivot:
      lt += 1
      arr[i], arr[lt] = arr[lt], arr[i]
      i += 1
    elif arr[i] > pivot:
      gt -= 1
      arr[i], arr[gt] = arr[gt], arr[i]
    else:
      i += 1
  return lt + 1, gt