排序算法是将一组元素按照特定顺序重新排列的算法。排序在计算机科学中是一个基本且常见的问题，有许多不同的排序算法，每个都有其独特的优势和劣势。
常见的排序算法
以下是一些常见的排序算法的详细介绍：
-
冒泡排序（Bubble Sort）:
- 描述： 通过不断交换相邻元素，将较大的元素推向数组的一端，从而实现排序。
- 时间复杂度： 平均O(n^2)，最坏O(n^2)，最好O(n)（已排序时）。
- 空间复杂度： O(1)。
-
选择排序（Selection Sort）:
- 描述： 每次选择未排序部分的最小元素，与未排序部分的第一个元素交换位置。
- 时间复杂度： 平均O(n^2)，最坏O(n^2)，最好O(n^2)。
- 空间复杂度： O(1)。
-
插入排序（Insertion Sort）:
- 描述： 将未排序的元素逐个插入到已排序部分的合适位置。
- 时间复杂度： 平均O(n^2)，最坏O(n^2)，最好O(n)（已排序时）。
- 空间复杂度： O(1)。
-
归并排序（Merge Sort）:
- 描述： 将数组分成两半，对每一半进行归并排序，然后合并两个有序数组。
- 时间复杂度： 平均O(n log n)，最坏O(n log n)，最好O(n log n)。
- 空间复杂度： O(n)。
-
快速排序（Quick Sort）:
- 描述： 选择一个基准元素，将数组分为小于基准和大于基准的两部分，然后递归地对这两部分进行排序。
- 时间复杂度： 平均O(n log n)，最坏O(n^2)，最好O(n log n)。
- 空间复杂度： O(log n)。
-
堆排序（Heap Sort）:
- 描述： 构建一个最大堆（或最小堆），然后依次取出堆顶元素，再调整堆，重复这个过程直至排序完成。
- 时间复杂度： 平均O(n log n)，最坏O(n log n)，最好O(n log n)。
- 空间复杂度： O(1)。
-
计数排序（Counting Sort）:
- 描述： 统计每个元素的出现次数，然后根据统计信息对元素进行排序。
- 时间复杂度： 平均O(n + k)，最坏O(n + k)，最好O(n + k)。
- 空间复杂度： O(k)，其中k是元素范围。
-
基数排序（Radix Sort）:
- 描述： 将整数按照位数切割成不同的数字，然后按照每个位数分别进行排序。
- 时间复杂度： 平均O(nk)，最坏O(nk)，最好O(nk)。
- 空间复杂度： O(n + k)。
这些排序算法的选择取决于实际问题的特征，例如数据规模、数据分布、对稳定性的要求等。在实际应用中，有时会根据具体情况选择不同的排序算法。
发展历程
排序算法的发展历程可以追溯到计算机科学的早期阶段。随着硬件和算法的不断演进，各种排序算法相继被提出和改进。以下是排序算法的主要发展历程：
-
早期算法（1950年代-1960年代）:
- 早期计算机系统中常用的是基于插入排序的简单算法，因为那时计算机的存储容量和处理速度都非常有限。冒泡排序、插入排序等属于这个阶段的算法。
-
冒泡排序（Bubble Sort）:
- 冒泡排序是最早被提出的排序算法之一，其基本思想是通过相邻元素的比较和交换，将较大的元素逐渐交换到数组的末尾。
-
选择排序（Selection Sort）:
- 选择排序也是较早的排序算法，其核心思想是每次选择未排序部分的最小元素，与未排序部分的第一个元素交换位置。
-
归并排序（Merge Sort）:
- 归并排序的概念最早由约翰·冯·诺伊曼在1945年提出。然而，真正的合并排序算法是由约翰·威廉·兹莫纳（John von Neumann）于1945年设计的。
-
快速排序（Quick Sort）:
- 快速排序是由托尼·霍尔（Tony Hoare）在1960年提出的。它是一种分而治之的算法，通过选择一个基准元素，将数组分为两部分，然后对每一部分递归地应用快速排序。
-
堆排序（Heap Sort）:
- 堆排序是由罗伯特·弗洛伊德（Robert W. Floyd）在1964年提出的。它使用了堆数据结构，通过建立最大堆（或最小堆）来实现排序。
-
计数排序（Counting Sort）:
- 计数排序最早由哈罗德·斯尔德曼（Harold Seward）在1954年提出，但是它的实际应用是在后来的年代。
-
基数排序（Radix Sort）:
- 基数排序的概念最早由赫尔曼·霍普克罗夫特（Herman H. Goldstine）和约翰·冯·诺伊曼在1951年提出，但实际应用较晚。
随着计算机硬件的不断发展，研究者们提出了更多高效的排序算法，并进行了不断的改进。总的来说，排序算法的发展历程是一个逐步优化、提高效率的过程，不同的算法在不同的应用场景中有着各自的优势。
插入排序
插入排序是一种简单但有效的排序算法，其基本思想是将一个元素插入到已经排好序的部分，逐步构建有序序列。以下是使用Python实现插入排序的示例代码：
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
# 示例
arr = [12, 11, 13, 5, 6]
insertion_sort(arr)
print("排序后的数组:", arr)
这个示例中，insertion_sort 函数接受一个列表作为参数，并对其进行插入排序。排序后的结果将直接在原始数组上进行修改。
在每一轮循环中，算法将当前元素与已排序的部分进行比较，并将比它大的元素向右移动，直到找到合适的位置插入。这样，每次循环都会将一个元素插入到已排序部分，最终完成排序。
注意：插入排序是一种稳定排序算法，其时间复杂度为O(n^2)，其中n是数组的长度。
冒泡排序
冒泡排序是一种简单的排序算法，其基本思想是通过多次遍历待排序的序列，在每一轮遍历中比较相邻的两个元素，如果它们的顺序不符合要求（比如升序要求前面的元素小于后面的元素），则交换它们。这样，每一轮遍历都会使得最大的元素沉到序列的最后，直到整个序列有序。
以下是使用Python实现冒泡排序的示例代码：
def bubble_sort(arr):
n = len(arr)
# 外层循环控制遍历的次数
for i in range(n):
# 内层循环控制每一轮遍历中相邻元素的比较和交换
for j in range(0, n - i - 1):
# 如果相邻元素的顺序不符合要求，则交换它们
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
bubble_sort(arr)
print("排序后的数组:", arr)
在这个示例中，bubble_sort 函数接受一个列表作为参数，并对其进行冒泡排序。排序后的结果将直接在原始数组上进行修改。
在每一轮的内层循环中，相邻元素的比较和交换操作会使得最大的元素逐步移动到序列的最后。外层循环控制了整个排序过程的次数，确保每个元素都有足够的机会沉到它最终的位置。
冒泡排序的时间复杂度为O(n^2)，其中n是数组的长度。虽然冒泡排序的性能不如一些高级排序算法，但由于其简单的实现方式，它在某些特定情况下仍然是一个有用的排序算法。
选择排序
选择排序是一种简单的排序算法，其基本思想是每次从未排序的部分选择最小（或最大）的元素，然后与未排序部分的第一个元素交换位置。以下是使用Python实现选择排序的示例代码：
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]
# 测试
my_list = [64, 34, 25, 12, 22, 11, 90]
selection_sort(my_list)
print("排序后的数组:", my_list)
这个函数selection_sort接受一个列表作为输入，并对其进行选择排序。在每一次迭代中，它找到未排序部分的最小元素的索引，然后将该元素与未排序部分的第一个元素进行交换。这样，未排序部分的最小元素被移到已排序部分的末尾。上述示例中，通过调用selection_sort函数对my_list进行排序，并输出结果。
请注意，选择排序不是最有效率的排序算法，其时间复杂度为O(n^2)，其中n是数组的长度。在实际应用中，更常用的排序算法包括快速排序、归并排序和内置的排序函数。
归并排序
归并排序是一种分治法的经典排序算法，它将一个未排序的列表分成两个子列表，对每个子列表进行递归排序，然后将两个有序的子列表合并成一个有序的列表。以下是使用Python实现归并排序的示例代码：
def merge_sort(arr):
if len(arr) > 1:
mid = len(arr) // 2 # 找到中间索引
left_half = arr[:mid] # 切分为左半部分
right_half = arr[mid:] # 切分为右半部分
merge_sort(left_half) # 递归排序左半部分
merge_sort(right_half) # 递归排序右半部分
i = j = k = 0
# 合并两个有序的子列表
while i < len(left_half) and j < len(right_half):
if left_half[i] < right_half[j]:
arr[k] = left_half[i]
i += 1
else:
arr[k] = right_half[j]
j += 1
k += 1
# 检查左半部分是否有剩余元素
while i < len(left_half):
arr[k] = left_half[i]
i += 1
k += 1
# 检查右半部分是否有剩余元素
while j < len(right_half):
arr[k] = right_half[j]
j += 1
k += 1
# 测试
my_list = [64, 34, 25, 12, 22, 11, 90]
merge_sort(my_list)
print("排序后的数组:", my_list)
这个函数merge_sort采用递归的方式实现归并排序。在每一层递归中，列表被分成两半，然后递归地对左右两半进行排序，最后合并这两个有序的子列表。在合并的过程中，通过比较左右两半的元素，按照升序的顺序合并它们。
归并排序的时间复杂度是O(n log n)，其中n是数组的长度。尽管它在时间复杂度上相对较高，但归并排序具有稳定性和可预测性，适用于各种数据集。
快速排序
下面是使用Python实现快速排序的代码示例：
def quick_sort(arr):
if len(arr) <= 1:
return arr
else:
pivot = arr[0] # 选择第一个元素作为基准点
less = [x for x in arr[1:] if x <= pivot]
greater = [x for x in arr[1:] if x > pivot]
return quick_sort(less) + [pivot] + quick_sort(greater)
# 测试
my_list = [64, 34, 25, 12, 22, 11, 90]
sorted_list = quick_sort(my_list)
print("排序后的数组:", sorted_list)
这个函数quick_sort采用递归的方式实现快速排序。在每一次递归中，选择一个基准点（通常是列表的第一个元素），然后将列表分成两部分，一部分小于等于基准点，一部分大于基准点。然后递归地对这两部分进行快速排序，最后将结果合并在一起。
快速排序的平均时间复杂度为O(n log n)，其中n是数组的长度。它是一种原地排序算法，但在最坏情况下的时间复杂度为O(n^2)。尽管如此，在实践中，快速排序通常比其他O(n log n)的排序算法快，因为它的内部循环可以在许多情况下更有效率。
堆排序
下面是使用Python实现堆排序的代码示例：
def heapify(arr, n, i):
largest = i # 初始化最大元素的索引为根节点
left_child = 2 * i + 1
right_child = 2 * i + 2
# 如果左子节点存在且大于根节点，则更新最大元素的索引
if left_child < n and arr[i] < arr[left_child]:
largest = left_child
# 如果右子节点存在且大于根节点和左子节点，则更新最大元素的索引
if right_child < n and arr[largest] < arr[right_child]:
largest = right_child
# 如果最大元素的索引不等于根节点，则交换它们，并递归调用堆化过程
if largest != i:
arr[i], arr[largest] = arr[largest], arr[i]
heapify(arr, n, largest)
def heap_sort(arr):
n = len(arr)
# 构建最大堆
for i in range(n // 2 - 1, -1, -1):
heapify(arr, n, i)
# 逐步从最大堆中取出元素并进行堆化
for i in range(n - 1, 0, -1):
arr[i], arr[0] = arr[0], arr[i] # 交换根节点（最大值）和当前未排序部分的最后一个元素
heapify(arr, i, 0) # 对剩余的未排序部分进行堆化
# 测试
my_list = [64, 34, 25, 12, 22, 11, 90]
heap_sort(my_list)
print("排序后的数组:", my_list)
这个实现中，heapify函数用于将以节点i为根的子树调整为最大堆。然后，heap_sort函数首先构建一个最大堆，然后逐步将最大元素（根节点）与当前未排序部分的最后一个元素交换，并对剩余的未排序部分进行堆化。重复这个过程直到整个数组有序。
堆排序的时间复杂度为O(n log n)，其中n是数组的长度。虽然它不是一个原地排序算法，但由于它的空间复杂度为O(1)，在实际应用中仍然是一个有效的排序算法。
计数排序
计数排序是一种非比较排序算法，适用于一定范围内的整数排序。它通过统计每个元素的出现次数，然后根据这些统计信息重建有序序列。以下是使用Python实现计数排序的示例代码：
def counting_sort(arr):
# 找到数组中的最大值和最小值
max_val, min_val = max(arr), min(arr)
range_of_elements = max_val - min_val + 1
# 初始化计数数组，用于存储每个元素的出现次数
count_array = [0] * range_of_elements
# 计算每个元素的出现次数
for num in arr:
count_array[num - min_val] += 1
# 重新构建有序序列
sorted_array = []
for i in range(range_of_elements):
while count_array[i] > 0:
sorted_array.append(i + min_val)
count_array[i] -= 1
return sorted_array
# 测试
my_list = [4, 2, 2, 8, 3, 3, 1]
sorted_list = counting_sort(my_list)
print("排序后的数组:", sorted_list)
在这个实现中，首先找到数组中的最大值和最小值，然后初始化一个计数数组，用于记录每个元素的出现次数。接下来，遍历原始数组，增加计数数组中相应元素的计数。最后，根据计数数组的信息，构建有序的结果数组。
计数排序的时间复杂度为O(n + k)，其中n是数组的长度，k是元素的范围（最大值与最小值之差加1）。计数排序是一种稳定的排序算法，但需要额外的空间来存储计数数组。在元素范围较大时，计数排序可能不是最优选择。
基数排序
基数排序是一种非比较排序算法，它根据关键字的每一位的值，将待排序元素分配到桶中，然后按照桶的顺序和值重新构建序列。以下是使用Python实现基数排序的示例代码：
def radix_sort(arr):
# 找到数组中的最大值，确定最大值的位数
max_val = max(arr)
max_digit = len(str(max_val))
# 进行基数排序，从个位到最高位
for digit in range(max_digit):
# 初始化10个桶（0到9）
buckets = [[] for _ in range(10)]
# 将元素分配到桶中
for num in arr:
# 获取当前位上的数字
digit_val = (num // (10 ** digit)) % 10
buckets[digit_val].append(num)
# 重新构建有序序列
arr = [num for bucket in buckets for num in bucket]
return arr
# 测试
my_list = [170, 45, 75, 90, 802, 24, 2, 66]
sorted_list = radix_sort(my_list)
print("排序后的数组:", sorted_list)
在这个实现中，首先找到数组中的最大值，确定最大值的位数。然后进行基数排序，从个位到最高位，每次根据当前位上的数字将元素分配到相应的桶中，然后重新构建有序序列。
基数排序的时间复杂度为O(k * n)，其中n是数组的长度，k是最大值的位数。基数排序是一种稳定的排序算法，适用于整数或字符串等具有固定长度的元素。在某些情况下，基数排序可以比较高效。
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
