目录
-
-
-
- 前言
- [1. 冒泡排序 (Bubble Sort)](#1. 冒泡排序 (Bubble Sort))
- [2. 选择排序 (Selection Sort)](#2. 选择排序 (Selection Sort))
- [3. 插入排序 (Insertion Sort)](#3. 插入排序 (Insertion Sort))
- [4. 快速排序 (Quick Sort)](#4. 快速排序 (Quick Sort))
- [5. 归并排序 (Merge Sort)](#5. 归并排序 (Merge Sort))
- [6. 堆排序 (Heap Sort)](#6. 堆排序 (Heap Sort))
- Python内置的`sorted()`函数
- 总结
-
-
前言
排序算法是计算机科学中一个非常基本但又极为重要的主题。无论是数据分析、搜索算法，还是日常编程任务中，排序操作都频繁出现。Python 作为一个高级编程语言，内置了强大的排序功能，同时也允许开发者根据需求自定义排序算法。在这篇博客中，我们将介绍几种常见的排序算法，并展示如何在 Python 中实现它们。
1. 冒泡排序 (Bubble Sort)
冒泡排序是一种简单的交换排序算法。它的基本思想是反复比较相邻的元素，如果前一个元素大于后一个元素，就交换它们的位置，直到整个序列有序为止。
代码示例：
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]
return arr时间复杂度：
- 最优时间复杂度：O(n) （当列表已经有序）
- 平均时间复杂度：O(n²)
- 最差时间复杂度：O(n²)
冒泡排序虽然简单，但效率较低，特别是对于大规模数据集。
2. 选择排序 (Selection Sort)
选择排序每次从未排序的部分选择最小的元素，将其放到已排序部分的末尾。它是一种不稳定的排序算法。
代码示例：
python
def selection_sort(arr):
n = len(arr)
for i in range(n):
min_idx = i
for j in range(i+1, n):
if arr[j] < arr[min_idx]:
min_idx = j
arr[i], arr[min_idx] = arr[min_idx], arr[i]
return arr时间复杂度：
- 最优时间复杂度：O(n²)
- 平均时间复杂度：O(n²)
- 最差时间复杂度：O(n²)
选择排序通常比冒泡排序更高效，因其交换次数较少。
3. 插入排序 (Insertion Sort)
插入排序通过逐一将元素插入到有序部分来构建最终的排序列表。它的工作方式类似于扑克牌的排序过程，逐个将每张牌插入到正确的位置。
代码示例：
python
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
return arr时间复杂度：
- 最优时间复杂度：O(n) （当列表已经有序）
- 平均时间复杂度：O(n²)
- 最差时间复杂度：O(n²)
插入排序对于小型数据集非常有效，并且在数据几乎有序的情况下表现优异。
4. 快速排序 (Quick Sort)
快速排序是一种基于分治法的高效排序算法。它通过选择一个基准点（pivot），将数组分为两部分，一部分比基准点小，另一部分比基准点大，然后递归地对这两部分进行排序。
代码示例：
python
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)时间复杂度：
- 最优时间复杂度：O(n log n)
- 平均时间复杂度：O(n log n)
- 最差时间复杂度：O(n²) （当选择的基准点不合适）
快速排序是平均情况下最快的排序算法之一，但需要谨慎选择基准点。
5. 归并排序 (Merge Sort)
归并排序也是一种分治法的排序算法。它将数组分成两部分，对每一部分进行排序，然后合并两个有序的部分，直到整个数组有序。
代码示例：
python
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
return merge(left, right)
def merge(left, right):
result = []
i = j = 0
while i < len(left) and j < len(right):
if left[i] < right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result.extend(left[i:])
result.extend(right[j:])
return result时间复杂度：
- 最优时间复杂度：O(n log n)
- 平均时间复杂度：O(n log n)
- 最差时间复杂度：O(n log n)
归并排序的优势在于稳定且在大规模数据时效率较高，缺点是需要额外的内存空间。
6. 堆排序 (Heap Sort)
堆排序是一种基于堆数据结构的排序算法。堆是一种特殊的完全二叉树，堆排序的基本思想是将数组转化为一个大顶堆（最大堆），然后从堆顶取出最大元素，将其与堆的最后一个元素交换，并对剩下的部分进行堆调整。
代码示例：
python
def heapify(arr, n, i):
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, 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)
return arr时间复杂度：
- 最优时间复杂度：O(n log n)
- 平均时间复杂度：O(n log n)
- 最差时间复杂度：O(n log n)
堆排序的优点在于它的空间复杂度为 O(1)，且具有不错的时间复杂度。
Python内置的sorted()函数
Python 提供了内置的 sorted() 函数和列表对象的 sort() 方法，都是基于 Timsort 实现的。Timsort 是一种混合排序算法，结合了归并排序和插入排序的优点，具有非常好的性能。
代码示例：
python
arr = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_arr = sorted(arr)
arr.sort()sorted() 函数返回一个新的已排序列表，而 sort() 方法则在原地对列表进行排序。
时间复杂度：
- 最优时间复杂度：O(n)
- 平均时间复杂度：O(n log n)
- 最差时间复杂度：O(n log n)
总结
不同的排序算法在不同的场景下具有不同的优势。对于小型数据集，简单的冒泡排序、插入排序可能表现得足够好。而在大数据集下，快速排序、归并排序以及 Python 的 Timsort 通常更为合适。选择排序算法时，除了考虑时间复杂度，还应考虑算法的空间复杂度和稳定性。
通过理解和实现这些经典的排序算法，不仅能提升我们对算法的理解，还能帮助我们在实际开发中选择最合适的算法来提高程序性能。在下一课中，我们将继续深入学习Python的算法内容，进一步提升编程能力。关注我，更多精彩内容敬请期待《Python算法》系列博客的下一课--Python深度优先搜索!