Python实现十大经典排序算法

大家好，我是涛哥，本文内容来自 涛哥聊Python ，转载请标原创。

更多Python学习内容：http://ipengtao.com

排序算法是计算机科学中的基本算法之一，广泛应用于数据处理和分析。本文将详细介绍用Python实现十大经典排序算法，包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序和基数排序。通过具体的示例代码，全面掌握这些基础算法。

冒泡排序

冒泡排序（Bubble Sort）是一种简单的交换排序算法，通过重复地遍历要排序的数组，每次比较相邻的两个元素并交换位置，如果它们的顺序错误。这个过程会让最大的元素“冒泡”到数组的末端。

冒泡排序代码示例

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

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = bubble_sort(arr)
print("冒泡排序结果：", sorted_arr)

选择排序

选择排序（Selection Sort）是一种简单直观的排序算法。它的工作原理是不断地从未排序部分中选择最小的元素，并将其放在已排序部分的末尾。

选择排序代码示例

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

# 示例
arr = [64, 25, 12, 22, 11]
sorted_arr = selection_sort(arr)
print("选择排序结果：", sorted_arr)

插入排序

插入排序（Insertion Sort）通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

插入排序代码示例

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

# 示例
arr = [12, 11, 13, 5, 6]
sorted_arr = insertion_sort(arr)
print("插入排序结果：", sorted_arr)

希尔排序

希尔排序（Shell Sort）是插入排序的一种更高效的改进版本。它通过比较远距离的元素来进行排序，从而加快了速度。

希尔排序代码示例

def shell_sort(arr):
    n = len(arr)
    gap = n // 2
    while gap > 0:
        for i in range(gap, n):
            temp = arr[i]
            j = i
            while j >= gap and arr[j - gap] > temp:
                arr[j] = arr[j - gap]
                j -= gap
            arr[j] = temp
        gap //= 2
    return arr

# 示例
arr = [12, 34, 54, 2, 3]
sorted_arr = shell_sort(arr)
print("希尔排序结果：", sorted_arr)

归并排序

归并排序（Merge Sort）是一种分治算法，将数组分成更小的数组，分别排序，然后合并。

归并排序代码示例

def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        L = arr[:mid]
        R = arr[mid:]

        merge_sort(L)
        merge_sort(R)

        i = j = k = 0
        while i < len(L) and j < len(R):
            if L[i] < R[j]:
                arr[k] = L[i]
                i += 1
            else:
                arr[k] = R[j]
                j += 1
            k += 1

        while i < len(L):
            arr[k] = L[i]
            i += 1
            k += 1

        while j < len(R):
            arr[k] = R[j]
            j += 1
            k += 1
    return arr

# 示例
arr = [12, 11, 13, 5, 6, 7]
sorted_arr = merge_sort(arr)
print("归并排序结果：", sorted_arr)

快速排序

快速排序（Quick Sort）是一种分治算法，通过选择一个基准元素，将数组分为两部分，一部分比基准元素小，另一部分比基准元素大，然后递归地对这两部分进行排序。

快速排序代码示例

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)

# 示例
arr = [10, 7, 8, 9, 1, 5]
sorted_arr = quick_sort(arr)
print("快速排序结果：", sorted_arr)

堆排序

堆排序（Heap Sort）利用堆这种数据结构来排序。堆是一种近似完全二叉树的结构，满足堆性质。

堆排序代码示例

def heapify(arr, n, i):
    largest = i
    l = 2 * i + 1
    r = 2 * i + 2

    if l < n and arr[l] > arr[largest]:
        largest = l

    if r < n and arr[r] > arr[largest]:
        largest = r

    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

# 示例
arr = [12, 11, 13, 5, 6, 7]
sorted_arr = heap_sort(arr)
print("堆排序结果：", sorted_arr)

计数排序

计数排序（Counting Sort）是一种非比较排序算法，适用于数据范围较小的整数排序。

计数排序代码示例

def counting_sort(arr):
    max_val = max(arr)
    m = max_val + 1
    count = [0] * m

    for a in arr:
        count[a] += 1

    i = 0
    for a in range(m):
        for c in range(count[a]):
            arr[i] = a
            i += 1
    return arr

# 示例
arr = [1, 4, 1, 2, 7, 5, 2]
sorted_arr = counting_sort(arr)
print("计数排序结果：", sorted_arr)

桶排序

桶排序（Bucket Sort）是计数排序的升级版，将数据分布到不同的桶中，然后对每个桶进行排序。

桶排序代码示例

def bucket_sort(arr):
    bucket = []
    slot_num = 10
    for i in range(slot_num):
        bucket.append([])

    for j in arr:
        index_b = int(slot_num * j)
        bucket[index_b].append(j)

    for i in range(slot_num):
        bucket[i] = sorted(bucket[i])

    k = 0
    for i in range(slot_num):
        for j in range(len(bucket[i])):
            arr[k] = bucket[i][j]
            k += 1
    return arr

# 示例
arr = [0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434]
sorted_arr = bucket_sort(arr)
print("桶排序结果：", sorted_arr)

基数排序

基数排序（Radix Sort）是一种非比较整数排序算法，通过按位排序实现。

基数排序代码示例

def counting_sort_for_radix(arr, exp):
    n = len(arr)
    output = [0] * n
    count = [0] * 10

    for i in range(n):
        index = arr[i] // exp
        count[index % 10] += 1

    for i in range(1, 10):
        count[i] += count[i - 1]

    i = n - 1
    while i >= 0:
        index = arr[i] // exp
        output[count[index % 10] - 1] = arr[i]
        count[index % 10] -= 1
        i -= 1

    for i in range(len(arr)):
        arr[i] = output[i]

def radix_sort(arr):
    max_val = max(arr)
    exp = 1
    while max_val // exp > 0:
        counting_sort_for_radix(arr, exp)
        exp *= 10
    return arr

# 示例
arr = [170, 45, 75, 90, 802, 24, 2, 66]
sorted_arr = radix_sort(arr)
print("基数排序结果：", sorted_arr)

总结

本文详细介绍了用Python实现的十大经典排序算法，包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序和基数排序。每个算法都通过具体的示例代码展示了其实现原理和步骤。这些排序算法是计算机科学中的基础知识，广泛应用于各种数据处理和分析任务。通过掌握这些排序算法，可以提高编程技能，优化代码性能，并更好地理解算法在实际应用中的重要性。