排序算法性能比较 python

冒泡排序、选择排序

堆排序、归并排序、快速排序

计数排序

import json
import random
import time

import matplotlib
import pandas


def Bubble_Sort(num):
    # 冒泡排序
    for i in range(len(num)-1):
        for j in range(len(num)-i-1):
            if num[j] > num[j+1]:
                num[j], num[j+1] = num[j+1], num[j]


def Selection_Sort(num):
    # 选择排序
    for i in range(0, len(num)-1):
        key = i
        for j in range(i+1, len(num)):
            if num[key] > num[j]:
                key = j
        if key != i:
            num[i], num[key] = num[key], num[i]


def Count_Sort(num, length):
    # 计数排序
    buff = [0 for i in range(0, length+1)]
    result = [0 for i in range(0, len(num))]
    for i in range(0, len(num)):
        # result.append(0)
        buff[num[i]] += 1
    # buff[i]中存放的是原始数据num[]中等于i的个数
    for i in range(1, length+1):
        buff[i] += buff[i-1]
    # buff[i]现在存放的是小于等于i的个数
    for i in range(len(num)-1, -1, -1):
        result[buff[num[i]]-1] = num[i]
        buff[num[i]] -= 1
    return result


def Merge(num, left, mid, right):
    # 归并排序中的 左右合并
    num_left = num[left:mid+1]
    num_right = num[mid+1:right+1]
    num_result = []
    while len(num_left) > 0 and len(num_right) > 0:
        if num_left[0] < num_right[0]:
            num_result.append(num_left.pop(0))
        else:
            num_result.append(num_right.pop(0))
    num_result += num_left
    num_result += num_right

    for i in range(left, right+1):
        num[i] = num_result[i-left]


def Merge_Sort(num, left, right):
    # 归并排序
    if left < right:
        mid = int((left+right)/2)
        Merge_Sort(num, left, mid)
        Merge_Sort(num, mid+1, right)
        Merge(num, left, mid, right)


def Max_Heapify(num, i, length):
    # 堆化 维护堆的性质
    # 下标从0开始 到length-1 结束
    left_child_location = 2*i+1
    right_child_location = 2*i+2

    if left_child_location <= length-1 and num[left_child_location] > num[i]:
        lagest = left_child_location
    else:
        lagest = i
    if right_child_location <= length-1 and num[right_child_location] > num[lagest]:
        lagest = right_child_location
    if lagest != i:
        num[i], num[lagest] = num[lagest], num[i]
        Max_Heapify(num, lagest, length)


def Build_Max_Heap(num):
    # 建堆 从无序数组中建最大堆
    for i in range(int((len(num)-2)/2), -1, -1):
        Max_Heapify(num, i, len(num))


def Heap_Sort(num):
    # 堆排序
    Build_Max_Heap(num)
    length = len(num)
    for i in range(len(num)-1, 0, -1):
        num[i], num[0] = num[0], num[i]
        length -= 1
        Max_Heapify(num, 0, length)


def Partition(num, left, right):
    # 以左边的数为基准   小的放基准左边 大的放的基准右边
    key = num[left]
    while left < right:
        while left < right and num[right] >= key:
            right = right-1
        if left < right:
            num[left] = num[right]
        while left < right and num[left] < key:
            left = left+1
        if left < right:
            num[right] = num[left]
        num[left] = key
    return left
    # 返回基准下标


def Quick_Sort(num, left, right):
    # 快速排序
    if left < right:
        key = Partition(num, left, right)
        Quick_Sort(num, left, key-1)
        Quick_Sort(num, key+1, right)


Max = 500000
# 随机数最大值


result_time = {}
# 存放所有运行时间的结果

for length in range(10000, 140000, 20000):
    # 数组长度

    # 生成随机数写入text.txt文件
    with open('text.txt', 'w+') as f:
        for i in range(0, length):
            f.write(str(random.randint(0, Max))+"\n")
        # 随机数 下限0 上限Max
    num = []
    # num中存放测试数据,保持数据一致性
    with open('text.txt', 'r+') as f:
        for line in f:
            num.append(int(line))
    # 从text.txt中读入需要排序的数据
    save_date = tuple(num)
    run_time = {}
    # 存放一组排序的运行时间
    result_time[length] = run_time
    print("\n**********"+str(length)+"**********")

    for i in range(0, 5):
        num = list(save_date)

        time_start = time.time()
        # 计时_开始时间
        if i == 0:
            num.sort()
            time_end = time.time()
            # 计时_结束时间
            run_time["sort"] = time_end-time_start
            print("sort:", run_time["sort"])
            with open("Result_sort.txt", "w+") as f:
                # 排序后结果存入Result_QuickSort.txt中
                for i in range(0, len(num)):
                    f.write(str(num[i])+"\n")

        elif i == 1:
            # 快速排序
            Quick_Sort(num, 0, len(num)-1)
            time_end = time.time()
            # 计时_结束时间
            run_time["Quick_Sort"] = time_end-time_start
            print("Quick_Sort:", run_time["Quick_Sort"])
            with open("Result_QuickSort.txt", "w+") as f:
                # 排序后结果存入Result_QuickSort.txt中
                for i in range(0, len(num)):
                    f.write(str(num[i])+"\n")

        elif i == 2:
            # 堆排序
            Heap_Sort(num)
            time_end = time.time()
            # 计时_结束时间
            run_time["Heap_Sort"] = time_end-time_start
            print("Heap_Sort:", run_time["Heap_Sort"])
            with open("Result_HeapSort.txt", "w+") as f:
                # 排序后结果存入Result_HeapSort.txt中
                for i in range(0, len(num)):
                    f.write(str(num[i])+"\n")

        elif i == 3:
            # 计数排序
            result = Count_Sort(num, Max)
            time_end = time.time()
            # 计时_结束时间
            run_time["Count_Sort"] = time_end-time_start
            print("Count_Sort:", run_time["Count_Sort"])
            with open("Result_CountSort.txt", "w+") as f:
                # 排序后结果存入Result_CountSort.txt中
                for i in range(0, len(result)):
                    f.write(str(result[i])+"\n")

        elif i == 4:
             # 归并排序
            Merge_Sort(num, 0, len(num)-1)
            time_end = time.time()
            # 计时_结束时间
            run_time["Merge_Sort"] = time_end-time_start
            print("Merge_Sort:", run_time["Merge_Sort"])
            with open("Result_MergeSort.txt", "w+") as f:
                # 排序后结果存入Result_MergeSort.txt中
                for i in range(0, len(num)):
                    f.write(str(num[i])+"\n")

        elif i == 5:
            # 选择排序
            Selection_Sort(num)
            time_end = time.time()
            # 计时_结束时间
            run_time["Selection_Sort"] = time_end-time_start
            print("Selection_Sort:", run_time["Selection_Sort"])
            with open("Result_SelectionSort.txt", "w+") as f:
                # 排序后结果存入Result_SelectionSort.txt中
                for i in range(0, len(num)):
                    f.write(str(num[i])+"\n")
  
        elif i == 6:
            # 冒泡排序
            Bubble_Sort(num)
            time_end = time.time()
            # 计时_结束时间
            run_time["Bubble_Sort"] = time_end-time_start
            print("Bubble_Sort:", run_time["Bubble_Sort"])
            with open("Result_BubbleSort.txt", "w+") as f:
             # 排序后结果存入Result_BubbleSort.txt中
                for i in range(0, len(num)):
                    f.write(str(num[i])+"\n")


with open("result_time.xls", "w+") as f:
        # 最后的运行时间存入result_time.xls的表格文档
    # 这里似乎有问题
    for key1 in result_time:
        f.write(str(key1))
        for key2 in result_time[key1]:
            f.write("\t")
            f.write(key2+"\t")
            f.write(str(result_time[key1][key2]))
            f.write("\n")
with open("result_time.json", "w+") as f:
        # 所有运行时间存入.json文档中
    json.dump(result_time, f)

# df = pandas.DataFrame(books).T.fillna(0)
df = pandas.DataFrame(result_time).T
print(df)