Python实现八大排序算法及所耗时间的柱形图

问题:
用Python实现八种排序算法,对随机产生的500个1000以内的数进行排序,统计不同算法的效率,并将其显示在柱状图或者折线图中。其他图也可以,可视化就行。

这里使用的八种排序算法分别是:冒泡、选择、插入、希尔、快排、归并、基数、堆排

# 用Python实现四种排序算法,对随机产生的500个1000以内的数进行排序
# 八大排序算法:冒泡、选择、插入、希尔、快排、归并、基数、堆排
import numpy as npy


# 交换列表中两个数的方法
def swap(my_list: list, a: int, b: int):
    """
    :param my_list: 列表
    :param a: 第一个数的下标
    :param b: 第二个数的下标
    :return:
    """
    temp = my_list[a]
    my_list[a] = my_list[b]
    my_list[b] = temp


# 冒泡排序
def bubble_sort(my_list: list) -> list:
    """
    冒泡排序:依次比较相邻两个数大小,如果错误,则交换顺序
    优化:增加一个bool类型变量,如果没有进行一次交换,说明排序已完成,无需继续
    :param my_list: 待排序的列表
    :return: 排序完成完成的列表
    """
    for i in range(len(my_list)-1):
        is_change = False  # 用于判断是否进行了交换
        for j in range(len(my_list)-1-i):
            if my_list[j] > my_list[j+1]:
                is_change = True
                swap(my_list, j, j+1)
        if not is_change:  # 优化
            break
    return my_list


# 选择排序
def select_sort(my_list: list) -> list:
    """
    选择排序:
    1.假定第一个为最小数,依次与后面的数比较,如果发现更小的数,记录其下标再让其作为最小值,继续与后面的数进行比较
        直到最后
    2.第一轮比较结束后,通过记录的最小数的下标,让最小数与假定的第一个数进行交换
    3.假定第二个数、第三个数...倒数第二个数重复以上步骤
    优化:如果记录的下标等于假定数的下标,则不用交换
    :param my_list: 待排序的列表
    :return: 排序完成完成的列表
    """
    for i in range(len(my_list)-1):
        min_index = i  # 假定最小数的下标
        min_num = my_list[i]  # 假定最小数
        for j in range(i+1, len(my_list)):
            if min_num > my_list[j]:  # 找到更小的数
                min_index = j
                min_num = my_list[j]
        if min_index != i:  # 优化
            my_list[min_index] = my_list[i]
            my_list[i] = min_num
    return my_list


# 插入排序
def insert_sort(my_list: list) -> list:
    """
    插入排序:
    1.从第二个数开始,用一个变量temp存放这个数,与前面的数依次进行比较,如果比当前数大,直接进行交换继续比较,如果比temp小,则结束
    2.第二个数到最后一个数重复第一步
    :param my_list: 待排序的列表
    :return: 排序完成完成的列表
    """
    for i in range(1, len(my_list)):
        temp = my_list[i]  # 辅助变量,用于存放要找适当位置的数
        index = i-1  # 辅助指针
        while index > 0:
            if my_list[index] > temp:
                my_list[index + 1] = my_list[index]
            else:
                break
            index -= 1
        if i != index+1:
            my_list[index+1] = temp
        return my_list


# 希尔排序
def shell_sort(my_list: list) -> list:
    """
    希尔排序:
    1.对数列进行分组,len/2、len/2/2...1 直到len/2=1
    2.每次分完组,都对本组的数列进行插入排序
    :param my_list: 待排序的列表
    :return: 排序完成完成的列表
    """
    step = int(len(my_list) / 2)
    while step > 0:
        i = step
        while i < len(my_list):
            temp = my_list[i]
            index = i-1
            while index > 0:
                if my_list[index] > temp:
                    my_list[index+1] = my_list[index]
                else:
                    break
                index -= 1
            if index+1 != i:
                my_list[index+1] = temp
            i += 1
        step /= 2
        step = int(step)  # 进行取整
    return my_list


# 快速排序
def quick_sort(my_list: list, left: int, right: int) -> list:
    """
    快速排序:
    基本思想就是分治,每次其实就是进行填坑(将比第一次坑中的数即要处理的数大的放右边,小的放左边)
    如: 1.先定好左指针(left)和右指针(right),用一个辅助变量temp记录要处理的数
        2.假设第一个就是要处理的数(第一次坑中的数),从right开始向左找,找到比temp小的数就停止,然后把这个比temp小的数放入坑中,此时坑变到比temp小的数的位置上,同时让left+1
        3.从left开始向右找,找到比temp大的数就停止,然后把这个比temp大的数放入第二步的新坑中,此时坑变到比temp大的数的位置上,同时让right-1
        4.重复第2、3步,直到left=right,这个位置就是最后一个坑了,将temp放入最后一个坑中,即left或right的位置,此时temp左边都是比它小的数,右边都是比它大的数,所有坑都填满了
    :param my_list: 待排序的列表
    :param left: 最左边的下标
    :param right: 最右边的下标
    :return: 排序完成的列表
    """
    if left < right:
        l = left
        r = right
        temp = my_list[l]  # 辅助变量,挖出的坑
        while l != r:
            while l != r:
                if my_list[r] < temp:
                    my_list[l] = my_list[r]
                    l += 1
                    break
                r -= 1
            while l != r:
                if my_list[l] > temp:
                    my_list[r] = my_list[l]
                    r -= 1
                    break
                l += 1
        my_list[l] = temp
        quick_sort(my_list, left, l-1)
        quick_sort(my_list, l+1, right)
        return my_list


# 归并排序
def merge_sort(my_list: list, left: int, right: int, temp_list: list) -> list:
    """
    归并排序:
    基本思想就是先分再合,分是自上而下分,分到不能再分了,如只有两个元素,合是从分得不能再分自下而上进行合并
    合并的具体思想是:利用一个辅助列表,再利用两个指针left(0<=left<=mid)和right(mid+1<=right<=数列长度-1),
        将指针所指向的更小的数填入到辅助列表
    :param my_list: 待排序的列表
    :param left: 最左边的下标
    :param right: 最右边的下标
    :param temp_list: 辅助列表
    :return: 排序完成完成的列表
    """
    if left < right:
        mid = int((left + right)/2)  # 要进行取整
        merge_sort(my_list, left, mid, temp_list)  # 向左分
        merge_sort(my_list, mid+1, right, temp_list)  # 向右分
        l = left  # 左指针
        r = mid+1  # 右指针
        t = 0  # 辅助列表的辅助指针
        while l <= mid and r <= right:
            if my_list[l] < my_list[r]:
                temp_list[t] = my_list[l]
                t += 1
                l += 1
            else:
                temp_list[t] = my_list[r]
                t += 1
                r += 1
        while l <= mid:
            temp_list[t] = my_list[l]
            t += 1
            l += 1
        while r <= right:
            temp_list[t] = my_list[r]
            t += 1
            r += 1
        t = 0  # 让辅助列表的辅助指针归零
        t2 = left  # 待排序列表的辅助指针
        while t2 <= right:
            my_list[t2] = temp_list[t]
            t2 += 1
            t += 1
    return my_list


# 基数排序
def radix_sort(my_list: list) -> list:
    """
    类似桶排序
    :param my_list: 待排序的列表
    :return: 排序完成的列表
    """
    # 创建10个桶每个桶的大小为待排序列表的元素个数
    barrels = [[0 for i in range(len(my_list))] for i in range(10)]
    count = [0 for i in range(10)]  # 用于记录每个桶中数的个数
    # 首先,找到待排序列表最大数的位数
    max_num = max(my_list)
    digit = len(str(max_num))  # 待排序列表中的最大位数
    for i in range(digit):
        # 将所有数放入对应的桶中
        for j in range(len(my_list)):
            mold = int(my_list[j] / 10**i % 10)  # 取模的结果代表放入第几号桶
            barrels[mold][count[mold]] = my_list[j]
            count[mold] += 1
        # 将桶中的数依次放入待排序列表中
        t = 0  # 辅助指针
        for j in range(10):
            if count[j] != 0:  # 如果桶不为空
                for k in range(count[j]):  # 取出桶中的数
                    my_list[t] = barrels[j][k]
                    t += 1
                count[j] = 0  # 取完后,桶置空
    return my_list


# 获得小的大顶堆的方法
def get_small_heap(my_list: list, index: int, length: int):
    """
    :param my_list: 待排序的列表
    :param index: 非叶子节点的下标
    :param length: 列表长度
    :return:
    """
    left = 2*index+1  # 非叶子节点的左子节点
    while left < length:
        right = left+1  # 右子节点
        if right < length and my_list[right] > my_list[left]:  # 如果右子节点存在并且大于左子节点
            left = right
        if my_list[index] < my_list[left]:  # 将大的子节点作为父节点
            swap(my_list, index, left)
            index = left
        else:
            break
        left = 2*left+1


# 堆排序
def heap_sort(my_list: list) -> list:
    """
    堆排序:
    1.先构建大顶堆
    2.然后将堆顶的数与最后一个数进行交换,此时最后一个数就是最大的,可以排除最后一个元素了,此时只需要将堆顶的元素放到合适的位置
    3.将堆顶的数自上而下放到合适的位置
    4.重复2、3步,直到剩下最后一个元素
    :param my_list:  待排序的列表
    :return: 完成排序的列表
    """
    length = len(my_list)
    index = int(length / 2 - 1)  # 最后一个非叶子节点(要转为整数)
    while index >= 0:
        get_small_heap(my_list, index, length)
        index -= 1
    while length > 0:
        swap(my_list, 0, length-1)  # 先将最后一个数与堆顶的数进行交换
        length -= 1
        get_small_heap(my_list, 0, length)  # 将堆顶的数放到合适的位置
    return my_list


def main():
    print("20个随机数的8种排序结果如下")
    list1 = list(npy.random.randint(500, 10001, 20))
    print('待排序的列表:', list1)
    # 冒泡排序结果
    result1 = bubble_sort(list1)
    print('冒泡排序结果:', result1)
    # 选择排序结果
    result2 = select_sort(list1)
    print('选择排序结果:', result2)
    # 插入排序结果
    result3 = insert_sort(list1)
    print('插入排序结果:', result3)
    # 希尔排序结果
    result4 = shell_sort(list1)
    print('希尔排序结果:', result4)
    # 快速排序结果
    result5 = quick_sort(list1, 0, len(list1)-1)
    print('快速排序结果:', result5)
    # 归并排序结果
    list2 = [0 for i in range(len(list1))]
    result6 = merge_sort(list1, 0, len(list1)-1, list2)
    print('归并排序结果:', result6)
    # 基数排序结果
    result7 = radix_sort(list1)
    print('基数排序结果:', result7)
    # 堆排序结果
    result8 = heap_sort(list1)
    print('堆排序的结果:', result8)


if __name__ == '__main__':
    # 展示8种排序对20个数排序后的结果
    main()

结果:
Python实现八大排序算法及所耗时间的柱形图_第1张图片
由于冒泡、选择、插入排序数据量大的时候效率特别低,所以不考虑

希尔排序 快速排序 归并排序 基数排序 堆排序
8w数据 20ms左右 15-35ms 20ms内 50ms内 20ms内
80w 数据 200ms左右 100ms左右 130ms内 100ms内 150ms内
800w数据 2-3s 1s左右 5s内 500ms内 2s左右
import numpy as npy
import matplotlib.pyplot as plt


def draw():
    # 解决中文显示问题
    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    # 由于冒泡、选择、插入排序数据量的的时候效率特别低,所以不考虑
    x = npy.array(range(1, 13, 4))
    x_ticks = [8, 80, 800]
    colors = ['red', 'yellow', 'blue', 'green', 'purple']
    labels = ['希尔排序', '快速排序', '归并排序', '基数排序', '堆排序']
    # 测试8万、80万、800万个数,得出以下数据
    y1 = [21, 201, 2123]
    y2 = [32, 103, 997]
    y3 = [19, 112, 1375]
    y4 = [46, 98, 467]
    y5 = [18, 123, 2011]
    plt.bar(x=[i-1.2 for i in x], height=y1, width=0.6, color=colors[0], label=labels[0])
    plt.bar(x=[i-0.6 for i in x], height=y2, width=0.6, color=colors[1], label=labels[1])
    plt.bar(x=x, height=y3, width=0.6, color=colors[2], label=labels[2])
    plt.bar(x=[i+1.2 for i in x], height=y4, width=0.6, color=colors[3], label=labels[3])
    plt.bar(x=[i+0.6 for i in x], height=y5, width=0.6, color=colors[4], label=labels[4])

    plt.title('5种算法耗费的时间统计图')
    plt.xlabel('数据量/w')
    plt.ylabel('时间/ms')
    plt.legend()
    plt.xticks(x, x_ticks)

    plt.show()


if __name__ == '__main__':
    draw()

Python实现八大排序算法及所耗时间的柱形图_第2张图片

你可能感兴趣的:(Python学习)