10大经典排序算法：轻松掌握，手撕代码无压力！
2024-02-18 23:59:18
排序算法是计算机科学和生活中必不可少的基本工具。通过学习这些算法，您将可以：
- 提高算法思维能力
- 优化代码性能
- 理解复杂数据结构
- 解决现实世界中的问题
现在，让我们开始探索10大经典排序算法的奥秘吧！
- 冒泡排序
冒泡排序（Bubble Sort）是一种简单直观的排序算法。它的基本思想是：比较相邻的元素，如果前一个元素比后一个元素大，就交换它们的顺序。重复这个过程，直到没有元素需要交换为止。冒泡排序的代码实现如下：
def bubble_sort(array):
"""
冒泡排序算法
参数：
array：需要排序的数组
返回：
排序后的数组
"""
for i in range(len(array)):
for j in range(0, len(array) - i - 1):
if array[j] > array[j + 1]:
array[j], array[j + 1] = array[j + 1], array[j]
return array
- 选择排序
选择排序（Selection Sort）是一种简单有效的排序算法。它的基本思想是：在数组中找到最小的元素，将其放在数组的开头，然后在剩余的数组中找到最小的元素，将其放在数组的第二个位置，以此类推。选择排序的代码实现如下：
def selection_sort(array):
"""
选择排序算法
参数：
array：需要排序的数组
返回：
排序后的数组
"""
for i in range(len(array)):
min_index = i
for j in range(i + 1, len(array)):
if array[j] < array[min_index]:
min_index = j
array[i], array[min_index] = array[min_index], array[i]
return array
- 插入排序
插入排序（Insertion Sort）是一种简单易懂的排序算法。它的基本思想是：将数组中的元素逐个插入到正确的位置，使其保持有序。插入排序的代码实现如下：
def insertion_sort(array):
"""
插入排序算法
参数：
array：需要排序的数组
返回：
排序后的数组
"""
for i in range(1, len(array)):
current_element = array[i]
j = i - 1
while j >= 0 and current_element < array[j]:
array[j + 1] = array[j]
j -= 1
array[j + 1] = current_element
return array
- 快速排序
快速排序（Quick Sort）是一种非常高效的排序算法。它的基本思想是：选择数组中的一个元素作为枢纽，将数组分成两部分，然后递归地对这两部分进行排序。快速排序的代码实现如下：
def quick_sort(array):
"""
快速排序算法
参数：
array：需要排序的数组
返回：
排序后的数组
"""
if len(array) < 2:
return array
pivot = array[len(array) // 2]
less = [i for i in array if i < pivot]
equal = [i for i in array if i == pivot]
greater = [i for i in array if i > pivot]
return quick_sort(less) + equal + quick_sort(greater)
- 归并排序
归并排序（Merge Sort）是一种非常高效的排序算法。它的基本思想是：将数组分成两部分，递归地对这两部分进行排序，然后将排序后的两部分合并成一个有序的数组。归并排序的代码实现如下：
def merge_sort(array):
"""
归并排序算法
参数：
array：需要排序的数组
返回：
排序后的数组
"""
if len(array) < 2:
return array
mid = len(array) // 2
left = merge_sort(array[:mid])
right = merge_sort(array[mid:])
return merge(left, right)
def merge(left, right):
"""
合并两个有序数组
参数：
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
- 堆排序
堆排序（Heap Sort）是一种非常高效的排序算法。它的基本思想是：将数组构建成一个最大堆，然后逐个将堆顶元素取出，并将其插入到数组的末尾。堆排序的代码实现如下：
def heap_sort(array):
"""
堆排序算法
参数：
array：需要排序的数组
返回：
排序后的数组
"""
def build_max_heap(array):
"""
构建最大堆
参数：
array：需要构建最大堆的数组
返回：
最大堆
"""
for i in range(len(array) // 2 - 1, -1, -1):
heapify(array, i)
def heapify(array, i):
"""
堆化
参数：
array：需要堆化的数组
i：当前节点的索引
返回：
堆化的数组
"""
largest = i
left = 2 * i + 1
right = 2 * i + 2
if left < len(array) and array[left] > array[largest]:
largest = left
if right < len(array) and array[right] > array[largest]:
largest = right
if largest != i:
array[i], array[largest] = array[largest], array[i]
heapify(array, largest)
build_max_heap(array)
for i in range(len(array) - 1, 0, -1):
array[0], array[i] = array[i], array[0]
heapify(array, 0)
return array
- 计数排序
计数排序（Counting Sort）是一种非常高效的排序算法。它的基本思想是：将数组中的每个元素映射到一个计数数组中，然后根据计数数组来构建一个新的有序数组。计数排序的代码实现如下：
def counting_sort(array):
"""
计数排序算法
参数：
array：需要排序的数组
返回：
排序后的数组
"""
max_value = max(array)
count_array = [0] * (max_value + 1)
for i in array:
count_array[i] += 1
sorted_array = []
for i in range(max_value + 1):
for j in range(count_array[i]):
sorted_array.append(i)
return sorted_array
- 桶排序
桶排序（Bucket Sort）是一种非常高效的排序算法。它的基本思想是：将数组中的元素分成若干个桶，然后对每个桶中的元素进行排序，最后将各个桶中的元素合并成一个有序的数组。桶排序的代码实现如下：
def bucket_sort(array):
"""
桶排序算法
参数：
array：需要排序的数组
返回：
排序后的数组
"""
max_value = max(array)
min_value = min(array)
bucket_size = (max_value - min_value) // len(array) + 1
buckets = [[] for _
