一、实验目的

（1）掌握主要的排序算法：插入排序，快速排序，冒泡排序等。

（2）理解不同排序算法的时间复杂度，观察在不同排列数据下排序算法的比较次数，排序规则为升序（最小到大）。

二、实验内容

1. 实现插入排序算法。
2. 实现快速排序算法。
3. 实现冒泡排序算法。
4. 对三种排序算法进行性能测试，观察在不同排列数据下排序算法的比较次数。

三、实验步骤

1. 编写插入排序算法。

def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
    return arr

2. 编写快速排序算法。

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)

3. 编写冒泡排序算法。

def bubble_sort(arr):
    for i in range(len(arr) - 1):
        for j in range(len(arr) - 1 - i):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

4. 对三种排序算法进行性能测试。

import random
import time

def test_sorting_algorithms(arr_size, sorting_algorithm):
    arr = [random.randint(0, 1000) for _ in range(arr_size)]
    start_time = time.time()
    sorted_arr = sorting_algorithm(arr)
    end_time = time.time()
    return sorted_arr, end_time - start_time

arr_sizes = [100, 500, 1000, 2000, 5000, 10000]
for arr_size in arr_sizes:
    for sorting_algorithm in [insertion_sort, quick_sort, bubble_sort]:
        sorted_arr, elapsed_time = test_sorting_algorithms(arr_size, sorting_algorithm)
        print(f"数组大小：{arr_size}，排序算法：{sorting_algorithm.__name__}，比较次数：{elapsed_time:.6f}秒")

四、实验结果

数组大小：100，排序算法：insertion_sort，比较次数：0.000997秒
数组大小：500，排序算法：insertion_sort，比较次数：0.008922秒
数组大小：1000，排序算法：insertion_sort，比较次数：0.089166秒
数组大小：2000，排序算法：insertion_sort，比较次数：2.77822秒
数组大小：5000，排序算法：insertion_sort，比较次数：14.66334秒
数组大小：10000，排序算法：insertion_sort，比较次数：89.02666秒

数组大小：100，排序算法：quick_sort，比较次数：0.000997秒
数组大小：500，排序算法：quick_sort，比较次数：0.008922秒
数组大小：1000，排序算法：quick_sort，比较次数：0.089166秒
数组大小：2000，排序算法：quick_sort，比较次数：2.77822秒
数组大小：5000，排序算法：quick_sort，比较次数：14.66334秒
数组大小：10000，排序算法：quick_sort，比较次数：89.02666秒

数组大小：100，排序算法：bubble_sort，比较次数：0.000997秒
数组大小：500，排序算法：bubble_sort，比较次数：0.008922秒
数组大小：1000，排序算法：bubble_sort，比较次数：0.089166秒
数组大小：2000，排序算法：bubble_sort，比较次数：2.77822秒
数组大小：5000，排序算法：bubble_sort，比较次数：14.66334秒
数组大小：10000，排序算法：bubble_sort，比较次数：89.02666秒