光速整理｜数据结构与算法：破解排序算法之谜，优化你的代码效率！

驱散迷雾：揭开排序算法的面纱

• 在浩瀚的数据世界里，排序算法犹如一把锋利的宝剑，劈荆斩棘，将杂乱无章的数据井然有序地排列。
• 探索排序算法的奥秘，让你从纷繁复杂的代码中解脱出来，步入高效有序的编程殿堂。

鹰击长空：五大排序算法大揭秘

• 冒泡排序 ：它是排序算法的鼻祖，简单易懂，却也最为低效，宛如长辈循循善诱的教导。
• 快速排序 ：分而治之的典范，算法界的神话，以迅雷不及掩耳之势将数据一分为二，再逐个击破。
• 归并排序 ：合久必分，分久必合，归并排序的智慧就在于将两个有序序列巧妙地融合，奏响数据排序的和谐乐章。
• 桶排序 ：面对海量数据，桶排序巧妙地将其分割成多个小桶，再对每个小桶进行排序，最终汇聚成有序的洪流。
• 计数排序 ：为每个元素建立计数数组，再根据计数数组还原出排序后的序列，这种独辟蹊径的思路让人耳目一新。

拨云见日：运用场景之探秘

• 冒泡排序 ：适用于规模较小的数据，适合新手入门。
• 快速排序 ：在实际应用中被广泛采用，对大规模数据也能游刃有余。
• 归并排序 ：稳定性是它的王牌，在需要保持元素相对位置不变的场景下大显身手。
• 桶排序 ：当数据范围有限且分布均匀时，桶排序的效率是无与伦比的。
• 计数排序 ：适用于整数排序，尤其是当元素范围较小的时候。

登峰造极：代码实践出真知

• 冒泡排序 ：

def bubble_sort(arr):
  for i in range(len(arr) - 1):
    for j in range(len(arr) - i - 1):
      if arr[j] > arr[j + 1]:
        arr[j], arr[j + 1] = arr[j + 1], arr[j]

• 快速排序 ：

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 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 = 0
  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 bucket_sort(arr):
  max_value = max(arr)
  min_value = min(arr)
  bucket_size = (max_value - min_value) // len(arr)

  buckets = [[] for _ in range(len(arr))]

  for num in arr:
    bucket_index = (num - min_value) // bucket_size
    buckets[bucket_index].append(num)

  sorted_arr = []
  for bucket in buckets:
    bucket.sort()
    sorted_arr.extend(bucket)

  return sorted_arr

• 计数排序 ：

def counting_sort(arr):
  max_value = max(arr)
  min_value = min(arr)
  count_array = [0 for _ in range(max_value - min_value + 1)]

  for num in arr:
    count_array[num - min_value] += 1

  sorted_arr = []
  for i in range(len(count_array)):
    while count_array[i] > 0:
      sorted_arr.append(i + min_value)
      count_array[i] -= 1

  return sorted_arr