(python)快速排序、合并排序、插入排序比较实验

(python)快速排序、合并排序、插入排序比较实验

实验题目

快速排序、合并排序、插入排序比较实验

实验要求

画出运行时间与n变化曲线对比图，并分析原因

实验目的

1、 掌握快速排序、合并排序与插入排序的算法思想
2、 编写实现快速排序、合并排序与插入排序算法
3、 比较快速排序、合并排序与插入排序不同n值所耗费的时间

实验步骤

1、实现快速排序算法

以下面5个无序的数据为例：65 27 59 64 58
第一次快排：27 58 59 65 64
第二次快排：27 58 59 64 65

def Quick_sort(list):
    """快速排序"""
    if len(list) < 2:
        return list
    # 选取基准，随便选哪个都可以，选中间的便于理解
    mid = list[len(list) // 2]
    # 定义基准值左右两个数列
    left, right = [], []
    # 从原始数组中移除基准值
    list.remove(mid)
    for item in list:
        # 大于基准值放右边
        if item >= mid:
            right.append(item)
        else:
            # 小于基准值放左边
            left.append(item)
    # 使用迭代进行比较
    return Quick_sort(left) + [mid] + Quick_sort(right)

2、非递归实现插入排序算法

#非递归实现插入排序
def Insert_sort(list):
    for i in range(1, len(list)):
        j = i
        while j>0 and list[j-1]>list[j]:
            list[j-1], list[j] = list[j], list[j-1]
            j -= 1

3、合并排序算法实现

def merge(a, b):
    c = []
    h = j = 0
    while j < len(a) and h < len(b):
        if a[j] < b[h]:
            c.append(a[j])
            j += 1
        else:
            c.append(b[h])
            h += 1
    if j == len(a):
        for i in b[h:]:
            c.append(i)
    else:
        for i in a[j:]:
            c.append(i)
    return c

def Merge_sort(list):
    if len(list) <= 1:
        return list
    middle = len(list)//2
    left = Merge_sort(list[:middle])
    right = Merge_sort(list[middle:])
    return merge(left, right)

4、统计函数运行时间

#函数运算时间
def time_Counter(func, seq):
    time_start = time.time()
    func(seq)
    time_end = time.time()
    return time_end-time_start

5、可视化显示实验结果

def ShowTimes(N, time1, time2, time3):
    #设置汉字格式
    font = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=14)
    plt.figure("Lab4")
    plt.title(u'不同n值插入排序、合并排序、快速排序算法所耗费的时间',FontProperties=font)
    plt.xlabel(u'n值',FontProperties=font)
    plt.ylabel(u'所需时间(s)',FontProperties=font)

    plt.scatter(x=N, y=time1, color='black',s=10)
    plt.scatter(x=N, y=time2, color='red',s=10)
    plt.scatter(x=N, y=time3, color='orange',s=10)

    plt.plot(N,time1,color='black')
    plt.plot(N,time2,color='red')
    plt.plot(N,time3,color='orange')

    insert_sort = mlines.Line2D([], [], color='black', marker='.',
                      markersize=10, label='insert_sort')
    merge_sort = mlines.Line2D([], [], color='red', marker='.',
                      markersize=10, label='merge_sort')
    quick_sort = mlines.Line2D([], [], color='orange', marker='.',
                      markersize=10, label='quick_sort')

    plt.legend(handles=[insert_sort,merge_sort,quick_sort])
    plt.show()

6、主函数设计

if __name__ == '__main__':
    N = []
    time1 = []
    time2 = []
    time3 = []
    for i in range(10,2600,100):
        list = []
        for j in range(0,i+1):
            list.append(j)
        random.shuffle(list)
        #复制列表list,保证两个排序函数进行排序的是同样的列表
        list_copy1 = list[:]
        list_copy2 = list[:]
        #非递归插入排序所耗费的时间
        time1.append(time_Counter(Insert_sort,list))
        
        #合并排序所耗费的时间
        time2.append(time_Counter(Merge_sort, list_copy1))

        #快速排序所耗费的时间
        time3.append(time_Counter(Quick_sort, list_copy2))
        N.append(i)
    ShowTimes(N,time1,time2,time3)
    #测试三个排序算法是否排序正确
    test = []
    for j in range(0,20):
            test.append(j)
    random.shuffle(test)
    test_copy1 = test[:]
    test_copy2 = test[:]
    print('原数据为：',test)
    Insert_sort(test)
    print('插入排序后：',test)
    print('归并排序后：',Merge_sort(test_copy1))
    print('快速排序后：',Quick_sort(test_copy2))

    print('插入排序所耗时间：',time1)
    print('合并排序所耗时间：',time2)
    print('快速排序所耗时间：',time3)

7、输出实验结果

总结

问题一：在随机数组中，快速排序和归并排序的所耗时间明显少于插入排序，且n值越大越明显。
原因分析：快速排序和归并排序的时间复杂度都为O(nlog(n))而插入排序的时间复杂度为O(n²)。
问题二：快速排序略微优于合并排序，且n值越大越明显。
原因分析：归并排序是先将数组不断细分成最小的单位，然后每个单位分别排序，排序完毕后合并，重复以上过程最后就可以得到排序结果。
快速排序是先选定一个基准元素，然后以该基准元素划分数组，再在被划分的部分重复以上过程，最后可以得到排序结果。
两者都是用分治法的思想，不过最后归并排序的合并操作比快速排序的要繁琐。

全部实验代码

import time
import random
import sys
sys.setrecursionlimit(1000000)
from matplotlib.font_manager import FontProperties
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.lines as mlines
import matplotlib.pyplot as plt

#非递归实现插入排序
def Insert_sort(list):
    for i in range(1, len(list)):
        j = i
        while j>0 and list[j-1]>list[j]:
            list[j-1], list[j] = list[j], list[j-1]
            j -= 1

def merge(a, b):
    c = []
    h = j = 0
    while j < len(a) and h < len(b):
        if a[j] < b[h]:
            c.append(a[j])
            j += 1
        else:
            c.append(b[h])
            h += 1
    if j == len(a):
        for i in b[h:]:
            c.append(i)
    else:
        for i in a[j:]:
            c.append(i)
    return c

def Merge_sort(list):
    if len(list) <= 1:
        return list
    middle = len(list)//2
    left = Merge_sort(list[:middle])
    right = Merge_sort(list[middle:])
    return merge(left, right)

def Quick_sort(list):
    """快速排序"""
    if len(list) < 2:
        return list
    # 选取基准，随便选哪个都可以，选中间的便于理解
    mid = list[len(list) // 2]
    # 定义基准值左右两个数列
    left, right = [], []
    # 从原始数组中移除基准值
    list.remove(mid)
    for item in list:
        # 大于基准值放右边
        if item >= mid:
            right.append(item)
        else:
            # 小于基准值放左边
            left.append(item)
    # 使用迭代进行比较
    return Quick_sort(left) + [mid] + Quick_sort(right)

#函数运算时间
def time_Counter(func, seq):
    time_start = time.time()
    func(seq)
    time_end = time.time()
    return time_end-time_start

def ShowTimes(N, time1, time2, time3):
    #设置汉字格式
    font = FontProperties(fname=r"c:\windows\fonts\simsun.ttc", size=14)
    plt.figure("Lab4")
    plt.title(u'不同n值插入排序、合并排序、快速排序算法所耗费的时间',FontProperties=font)
    plt.xlabel(u'n值',FontProperties=font)
    plt.ylabel(u'所需时间(s)',FontProperties=font)

    plt.scatter(x=N, y=time1, color='black',s=10)
    plt.scatter(x=N, y=time2, color='red',s=10)
    plt.scatter(x=N, y=time3, color='orange',s=10)

    plt.plot(N,time1,color='black')
    plt.plot(N,time2,color='red')
    plt.plot(N,time3,color='orange')

    insert_sort = mlines.Line2D([], [], color='black', marker='.',
                      markersize=10, label='insert_sort')
    merge_sort = mlines.Line2D([], [], color='red', marker='.',
                      markersize=10, label='merge_sort')
    quick_sort = mlines.Line2D([], [], color='orange', marker='.',
                      markersize=10, label='quick_sort')

    plt.legend(handles=[insert_sort,merge_sort,quick_sort])
    plt.show()

if __name__ == '__main__':
    N = []
    time1 = []
    time2 = []
    time3 = []
    for i in range(10,2600,100):
        list = []
        for j in range(0,i+1):
            list.append(j)
        random.shuffle(list)
        #复制列表list,保证两个排序函数进行排序的是同样的列表
        list_copy1 = list[:]
        list_copy2 = list[:]
        #非递归插入排序所耗费的时间
        time1.append(time_Counter(Insert_sort,list))

        #合并排序所耗费的时间
        time2.append(time_Counter(Merge_sort, list_copy1))

        #快速排序所耗费的时间
        time3.append(time_Counter(Quick_sort, list_copy2))
        N.append(i)
    ShowTimes(N,time1,time2,time3)
    #测试三个排序算法是否排序正确
    test = []
    for j in range(0,20):
            test.append(j)
    random.shuffle(test)
    test_copy1 = test[:]
    test_copy2 = test[:]
    print('原数据为：',test)
    Insert_sort(test)
    print('插入排序后：',test)
    print('归并排序后：',Merge_sort(test_copy1))
    print('快速排序后：',Quick_sort(test_copy2))

    print('插入排序所耗时间：',time1)
    print('合并排序所耗时间：',time2)
    print('快速排序所耗时间：',time3)