python实现排程算法 python写排序算法代码

转载

mob6454cc65110a 2023-11-14 09:47:20

文章标签 python实现排程算法 python 算法排序算法快速排序 文章分类 Python 后端开发

文章目录

1. 冒泡排序
2. 选择排序
3. 插入排序
4. 归并排序
5. 快速排序
比较说明

说明：本文主要使用python实现了五种基本的排序算法（冒泡排序、选择排序、插入排序、归并排序、快速排序），并比较了每种算法的运行耗时，借鉴了

每种算法的原理请参照上述的教程，写得非常简单易懂，此处不再复述算法原理

代码下载地址：

1. 冒泡排序

算法部分：

def bubbleSort(arr):
    for i in range(1,len(arr)): # 轮数
        for j in range(0,len(arr)-1): # 每一轮的循环比较
            if arr[j]>arr[j+1]:
                arr[j],arr[j+1] = arr[j+1],arr[j]
    return arr

测试部分：

import numpy as np
import time
import matplotlib.pyplot as plt

test_list=[10,100,1000,5000,10000]
time_list = []

print("=="*40)
for test_num in test_list:
    list_bubbleSort = np.random.randint(0,1000000,test_num)
    start = time.time()
    list_bubbleSort=bubbleSort(list_bubbleSort)
    end = time.time()
    print("{}个正整数排序耗时:{}".format(test_num,(end-start)))
    print("=="*40)
    time_list.append(end-start)
    
# 绘制时间曲线
plt.figure()
plt.plot(test_list,time_list,'r')
plt.title('ListSize-SortTime Map')
plt.xlabel('ListSize')
plt.ylabel('SortTime s')
plt.show()

结果部分：

================================================================================
10个正整数排序耗时:0.0
================================================================================
100个正整数排序耗时:0.008022308349609375
================================================================================
1000个正整数排序耗时:0.684316873550415
================================================================================
5000个正整数排序耗时:17.80435299873352
================================================================================
10000个正整数排序耗时:73.79979467391968
================================================================================

python实现排程算法 python写排序算法代码_排序算法

2. 选择排序

算法部分：

def selectionSort(arr):
    for i in range(len(arr)-1):
        min_index = i # 当前位置作为初始位置
        for j in range(i+1,len(arr)):
            if arr[j]<arr[min_index]:
                min_index = j # 更新最小值的索引
        if i != min_index: # 如果当前值不是最小值位置就替换位置
            arr[i], arr[min_index] = arr[min_index], arr[i] 
    return arr

测试部分：

import numpy as np
import time
import matplotlib.pyplot as plt

test_list=[10,100,1000,5000,10000]
time_list = []

print("=="*40)
for test_num in test_list:
    # 生成序列
    list_selectionSort = np.random.randint(0,10000,test_num)
    start = time.time()
    list_selectionSort=selectionSort(list_selectionSort)
    end = time.time()
    print("{}个正整数排序耗时:{}".format(test_num,(end-start)))
    print("=="*40)
    time_list.append(end-start)

# 绘制时间曲线
plt.figure()
plt.plot(test_list,time_list,'r')
plt.title('ListSize-SortTime Map')
plt.xlabel('ListSize')
plt.ylabel('SortTime s')
plt.show()

结果部分：

================================================================================
10个正整数排序耗时:0.0
================================================================================
100个正整数排序耗时:0.003536224365234375
================================================================================
1000个正整数排序耗时:0.24267196655273438
================================================================================
5000个正整数排序耗时:6.093706846237183
================================================================================
10000个正整数排序耗时:25.897886276245117
================================================================================

python实现排程算法 python写排序算法代码_python_02

3. 插入排序

算法部分：

def insertSort(arr):
    for i in range(len(arr)):
        pre_index = i-1
        current = arr[i]
        while pre_index >=0 and arr[pre_index]>current:
            # 第一个value不执行
            arr[pre_index+1]=arr[pre_index] #在current之前比current大的值向后移动
            pre_index -= 1
        arr[pre_index+1] = current
    return arr

测试部分：

import numpy as np
import time
import matplotlib.pyplot as plt

test_list=[10,100,1000,5000,10000]
time_list = []

print("=="*40)
for test_num in test_list:
    # 生成序列
    list_insertSort = np.random.randint(0,10000,test_num)
    start = time.time()
    list_insertSort=insertSort(list_insertSort)
    end = time.time()
    print("{}个正整数排序耗时:{}".format(test_num,(end-start)))
    print("=="*40)
    time_list.append(end-start)
    
# 绘制时间曲线
plt.figure()
plt.plot(test_list,time_list,'r')
plt.title('ListSize-SortTime Map')
plt.xlabel('ListSize')
plt.ylabel('SortTime s')
plt.show()

结果部分：

================================================================================
10个正整数排序耗时:0.0
================================================================================
100个正整数排序耗时:0.002505779266357422
================================================================================
1000个正整数排序耗时:0.18753337860107422
================================================================================
5000个正整数排序耗时:4.48946475982666
================================================================================
10000个正整数排序耗时:20.23084306716919
================================================================================

python实现排程算法 python写排序算法代码_算法_03

4. 归并排序

算法部分：

def mergeSort(arr):
    import math
    '''分解'''
    if(len(arr)<2):
        return arr
    middle = math.floor((len(arr))/2)
    left,right = arr[0:middle],arr[middle:] # 分解区间
    return merge(mergeSort(left),mergeSort(right)) # 递归

def merge(left,right):
    '''归并'''
    result = []
    while left and right: #当两个子集都有数值的时候，比较其顶部的两个值
        if left[0] <= right[0]:
            result.append(left.pop(0));
        else:
            result.append(right.pop(0));
    while left:
        result.append(left.pop(0));
    while right:
        result.append(right.pop(0));
    return result

测试部分：

import numpy as np
import time
import matplotlib.pyplot as plt

test_list=[10,100,1000,5000,10000,100000]
time_list = []

print("=="*40)
for test_num in test_list:
    # 生成序列
    list_mergeSort = np.random.randint(0,10000,test_num).tolist() # 输入一个list，不要ndarray格式
    start = time.time()
    list_mergeSort=mergeSort(list_mergeSort)
    end = time.time()
    print("{}个正整数排序耗时:{}".format(test_num,(end-start)))
    print("=="*40)
    time_list.append(end-start)
# 绘制时间曲线
plt.figure()
plt.plot(test_list,time_list,'r')
plt.title('ListSize-SortTime Map')
plt.xlabel('ListSize')
plt.ylabel('SortTime s')
plt.show()

结果部分：

================================================================================
10个正整数排序耗时:0.0
================================================================================
100个正整数排序耗时:0.0010023117065429688
================================================================================
1000个正整数排序耗时:0.011028528213500977
================================================================================
5000个正整数排序耗时:0.05063366889953613
================================================================================
10000个正整数排序耗时:0.08171701431274414
================================================================================
100000个正整数排序耗时:2.4911255836486816
================================================================================

python实现排程算法 python写排序算法代码_算法_04

5. 快速排序

算法部分：

def quickSort(arr,left=None,right=None):
    '''将最后一个值作为了主元'''
    left = 0 if not isinstance(left,(int,float)) else left # 如果left是布尔型的，left赋值为0，int或者float型的复制为其本身
    right = len(arr)-1 if not isinstance(right,(int,float)) else right # 如果right是布尔型，赋值为arr长度小1，否则赋值为其原值
    if left < right:
        partitionIndex = partition(arr, left, right) # 分解
        quickSort(arr, left, partitionIndex-1) # 递归处理
        quickSort(arr, partitionIndex+1, right)
    return arr

def partition(arr, left, right):
    pivot = left  #pivot——枢纽
    index = pivot+1
    i = index
    while  i <= right:
        if arr[i] < arr[pivot]:
            swap(arr, i, index)
            index+=1
        i+=1
    swap(arr,pivot,index-1)
    return index-1

def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]

测试部分：

import numpy as np
import time
import matplotlib.pyplot as plt

test_list=[10,100,1000,5000,10000,100000,1000000]
time_list = []

print("=="*40)
for test_num in test_list:
    # 生成序列
    list_quickSort = np.random.randint(0,10000,test_num).tolist() # 输入一个list，不要ndarray格式
    start = time.time()
    list_quickSort=quickSort(list_quickSort)
    end = time.time()
    print("{}个正整数排序耗时:{}".format(test_num,(end-start)))
    print("=="*40)
    time_list.append(end-start)
# 绘制一个时间曲线
plt.figure()
plt.plot(test_list,time_list,'r')
plt.title('ListSize-SortTime Map')
plt.xlabel('ListSize')
plt.ylabel('SortTime s')
plt.show()

结果部分：

================================================================================
10个正整数排序耗时:0.0
================================================================================
100个正整数排序耗时:0.0005011558532714844
================================================================================
1000个正整数排序耗时:0.013537168502807617
================================================================================
5000个正整数排序耗时:0.06116223335266113
================================================================================
10000个正整数排序耗时:0.12733149528503418
================================================================================
100000个正整数排序耗时:0.9735870361328125
================================================================================
1000000个正整数排序耗时:20.95492911338806
================================================================================

python实现排程算法 python写排序算法代码_python实现排程算法_05

比较说明

我电脑配置较低（不列出来了）在使用相对效率比较低的冒泡、选择和插入排序的时候最大测试了10000（1万）个数的排序测试，其最大耗时达到了73s，而对于效率较高的归并和快速排序算法我最大测试了1000000（一百万）个数的排序测试，其最大耗时也不过20s，由此可见通常而言快速排序算法和归并排序算法的效率是远高于其余几种算法的。对于算法的研究的确是非常有意义的。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。