Python算法实现：排序算法的Python实现

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

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

排序算法是计算机科学中最基础和最重要的算法之一。它们在数据处理中起着关键作用，广泛应用于搜索、数据分析和优化等领域。本文将详细介绍几种常见的排序算法及其Python实现，包括冒泡排序、选择排序、插入排序、归并排序和快速排序，并通过具体示例代码展示它们的工作原理和性能比较。

冒泡排序

算法概述

冒泡排序（Bubble Sort）是一种简单直观的排序算法。它反复地遍历待排序的序列，每次比较相邻的两个元素，如果它们的顺序错误就交换过来，直到整个序列有序。

实现步骤

1. 从序列的开头开始，依次比较相邻的两个元素。
2. 如果前一个元素比后一个元素大，则交换它们的位置。
3. 对整个序列重复上述步骤，直到没有元素需要交换。

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

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
print("排序前:", arr)
sorted_arr = bubble_sort(arr)
print("排序后:", sorted_arr)

选择排序

算法概述

选择排序（Selection Sort）是一种简单直观的排序算法。它的基本思想是每一轮从未排序的部分中选择最小（或最大）的元素，放到已排序的部分末尾。

实现步骤

1. 从未排序的部分中找到最小的元素。
2. 将这个元素与未排序部分的第一个元素交换位置。
3. 对剩余未排序部分重复上述步骤，直到整个序列有序。

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

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
print("排序前:", arr)
sorted_arr = selection_sort(arr)
print("排序后:", sorted_arr)

插入排序

算法概述

插入排序（Insertion Sort）是一种简单直观的排序算法。它的基本思想是将未排序部分的元素逐一插入到已排序部分的适当位置。

实现步骤

1. 从第一个元素开始，认为它是已排序的。
2. 取出下一个元素，在已排序部分从后向前扫描，找到合适的位置插入。
3. 重复上述步骤，直到整个序列有序。

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

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
print("排序前:", arr)
sorted_arr = insertion_sort(arr)
print("排序后:", sorted_arr)

归并排序

算法概述

归并排序（Merge Sort）是一种基于分治法的排序算法。它将序列分成两部分，分别排序后再合并，递归地进行直到序列有序。

实现步骤

1. 将序列分成两部分。
2. 分别对两部分进行排序。
3. 合并两部分，使其有序。

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
    return arr

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
print("排序前:", arr)
sorted_arr = merge_sort(arr)
print("排序后:", sorted_arr)

快速排序

算法概述

快速排序（Quick Sort）是一种基于分治法的排序算法。它通过选择一个“基准”元素，将序列分成两部分，一部分比基准小，一部分比基准大，递归地对两部分排序。

实现步骤

1. 选择一个基准元素。
2. 将序列分成两部分，一部分比基准小，一部分比基准大。
3. 递归地对两部分排序。

Python实现

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    else:
        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 = [64, 34, 25, 12, 22, 11, 90]
print("排序前:", arr)
sorted_arr = quick_sort(arr)
print("排序后:", sorted_arr)

各种排序算法的性能比较

时间复杂度

• 冒泡排序：平均情况和最坏情况时间复杂度均为O(n^2)。
• 选择排序：平均情况和最坏情况时间复杂度均为O(n^2)。
• 插入排序：平均情况时间复杂度为O(n^2)，最优情况为O(n)（已排序）。
• 归并排序：平均情况和最坏情况时间复杂度均为O(n log n)。
• 快速排序：平均情况时间复杂度为O(n log n)，最坏情况为O(n^2)。

稳定性

• 冒泡排序：稳定
• 选择排序：不稳定
• 插入排序：稳定
• 归并排序：稳定
• 快速排序：不稳定

示例测试

可以通过实际测试来比较不同排序算法的性能。以下是一个简单的性能测试示例。

import time
import random

# 生成随机数组
arr = [random.randint(1, 1000) for _ in range(1000)]

# 冒泡排序测试
start_time = time.time()
bubble_sort(arr.copy())
print("冒泡排序时间:", time.time() - start_time)

# 选择排序测试
start_time = time.time()
selection_sort(arr.copy())
print("选择排序时间:", time.time() - start_time)

# 插入排序测试
start_time = time.time()
insertion_sort(arr.copy())
print("插入排序时间:", time.time() - start_time)

# 归并排序测试
start_time = time.time()
merge_sort(arr.copy())
print("归并排序时间:", time.time() - start_time)

# 快速排序测试
start_time = time.time()
quick_sort(arr.copy())
print("快速排序时间:", time.time() - start_time)

总结

本文详细介绍了几种常见的排序算法及其Python实现，包括冒泡排序、选择排序、插入排序、归并排序和快速排序。通过具体的示例代码，展示了这些算法的工作原理和实现步骤，并比较了它们的性能和稳定性。掌握这些排序算法，可以帮助大家在数据处理和算法设计中更加得心应手，提高程序的效率和性能。