Python实现八大排序（基数排序、归并排序、堆排序、简单选择排序、直接插入排序、希尔排序、快速排序、冒泡排序）

八大排序

目录

• 八大排序
  • 基数排序
  • 归并排序
  • 堆排序
  • 简单选择排序
  • 直接插入排序
  • 希尔排序
  • 快速排序
  • 冒泡排序
  • 时间测试

大概了解了一下八大排序，发现排序方法的难易程度相差很多，相应的，他们计算同一列表的时间也不尽相同。今天，我就准备了八种排序的python代码，并且准备测试一下他们计算的时间

基数排序

基数排序的基本思想是先将数字按照个位数上数字的大小进行排序，排序之后再将已经排过序的数字再按照十位数上数字的大小进行排序，依次推类

# 统计这个列表中数字最大的数字有几位
def radix_sort_nums(nums):
    max = nums[0]
    for i in nums:
        if max < i:
            max = i
    times = 0
    while max > 0:
        max = int(max/10)
        times += 1
    return times

# 每个数字各个位置的数字大小，比如（123,1）则是3，（123,2）则是2
def get_num(num,n):
    return (int(num/(10**(n-1)))) % 10

# 主程序
def radix_sort(nums):
    count = 10*[None]	# 定义的数组，用于存放当前位数的元素个数
    bucket = len(nums)*[None]	# 用于暂时存放排序结果
	# 分别从个位/十位/百位开始循环
    for pos in range(1, radix_sort_nums(nums)+1):
		# 每次排序完都要清空各个位数存放的数据统计
        for i in range(10):
            count[i] = 0

        for i in range(len(nums)):
			# 获得0到9每个位数的个数
            j = get_num(nums[i], pos)
            count[j] = count[j]+1
		# 获得相对应位数的边界值
        for i in range(1, 10):
            count[i] = count[i] + count[i-1]

        for i in range(len(nums)-1, -1, -1):
			# 求出相应位数的数字
            j = get_num(nums[i], pos)
			将元素按相应位数的上数字的大小排序
            bucket[count[j]-1] = nums[i]
			让相应位数上数字相等的元素不会放在同一位置而被替代
            count[j] = count[j]-1

		# 将暂时存储在bucket的元素数据返回到nums中
        for i in range(0, len(nums)):
            nums[i] = bucket[i]
    return nums

print(radix_sort([45, 32, 8, 33, 12, 22, 19, 97]))

归并排序

归并排序其实是将原数列分为很多个小数列将其排序，在小数列排序完之后，再将各个小数列进行排序，最后得到一个全部有序的数列

# 归并排序

# 这个函数主要目的是为了实现合并并排序
def mergearray(nums, first, mid, last, temp):
	# i, j分别是第一个组数的第一个位置，第二组数的第一个位置
    i, j, k = first, mid+1, 0
	# 当俩边数组都存在数的时候，依次比较对应位置的大小
    while i <= mid and j <= last:
        if nums[i] <= nums[j]:
            temp[k] = nums[i]
            i = i+1
            k = k+1
        else:
            temp[k] = nums[j]
            j = j+1
            k = k+1
	# 第一组数还有多的数的情况
    while i <= mid:
        temp[k] = nums[i]
        i = i+1
        k = k+1
	# 第二组数还有多的情况
    while (j <= last):
        temp[k] = nums[j]
        j = j+1
        k = k+1
	# 将排列过的数组赋予nums（开始的时候只是部分有序，随着递归最后变成全部有序）
    for i in range(k):
        nums[first+i] = temp[i]

# 分组，利用递归
def merge_sort(nums,first,last,temp):
    if first < last:
        mid = int((first + last) / 2)
		# 分出第一组数
        merge_sort(nums, first, mid, temp)
		# 分出第二组数
        merge_sort(nums, mid+1, last, temp)
		# 合并并排序
        mergearray(nums, first, mid, last, temp)

def merge_sort_array(nums):
	# 创建一个和想要排序数列相同数量的空列表
    temp = len(nums)*[None]
	# 利用递归进行排序
    merge_sort(nums, 0, len(nums)-1, temp)

print(merge_sort_array([45, 32, 8, 33, 12, 22, 19, 97]))

堆排序

堆排序利用了二叉树的结构，使子节点的值一直小于根节点

def big_endian(arr, start, end):
    root = start
    child = root * 2 + 1  # 左孩子
    while child <= end:
        # 孩子比最后一个节点还大，也就意味着最后一个叶子节点了，就得跳出去一次循环，已经调整完毕
        if child + 1 <= end and arr[child] < arr[child + 1]:
            # 为了始终让其跟子元素的较大值比较，如果右边大就左换右，左边大的话就默认
            child += 1
        if arr[root] < arr[child]:
            # 父节点小于子节点直接交换位置，同时坐标也得换，这样下次循环可以准确判断：是否为最底层，
            # 是不是调整完毕
            arr[root], arr[child] = arr[child], arr[root]
            root = child
            child = root * 2 + 1
        else:
            break

def heap_sort(nums):  # 无序区大根堆排序
    first = len(nums) // 2 - 1
    for start in range(first, -1, -1):
        # 从下到上，从左到右对每个节点进行调整，循环得到非叶子节点
        big_endian(nums, start, len(nums) - 1)  # 去调整所有的节点
    for end in range(len(nums) - 1, 0, -1):
        nums[0], nums[end] = nums[end], nums[0]  # 顶部尾部互换位置
        big_endian(nums, 0, end - 1)  # 重新调整子节点的顺序，从顶开始调整
    return nums

print(heap_sort([3, 1, 4, 9, 6, 7, 5, 8, 2, 10]))

简单选择排序

简单选择排序的方法则是将所选值与剩下值中比他小的值进行比较

比如选取第一个值，往后找到比他小的值就与其对调，对调后的值再接下去进行比较，直至找到最小的值，随后再第二个值……直至循环到倒数第二个值

def select_sort(nums):
	# 遍历所有的值
    for i in range(len(nums)):
		# 当前位置初始值
        min = nums[i]
		# 与比他后面的值进行比较，小则互换
        for j in range(i+1, len(nums)):
            if nums[j] < min:
                nums[j], min = min, nums[j]
		# 将值返回数列
        nums[i] = min
    return nums

print(select_sort([45, 32, 8, 33, 12, 22, 19, 97]))

直接插入排序

首先遍历所有元素，随后从第一个数开始将数列从后往前遍历，如果后面的数小于前面的数，则互换位置，依次推类，直到遍历完成

# 直接插入排序
def insert_sort(nums):
    for i in range(len(nums)-1):

        for j in range(i, -1, -1):

            if nums[j] > nums[j+1]:
                nums[j], nums[j + 1] = nums[j + 1], nums[j]

    return nums

print(insert_sort([45, 32, 8, 33, 12, 22, 19, 97]))

希尔排序

希尔排序其实就相当于对直接插入排序的升级版，每次都选取一半的长度，随后利用直接插入法进行排序，从而更快的获得结果

aaarticlea/jpeg;base64,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*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" alt="img">

def insert_shell(nums):
    # 初始化l值，此处利用序列长度的一半为其赋值
    l = int(len(nums)/2)
    # 第一层循环：依次改变l值对列表进行分组
    while l >= 1:
    # 下面：利用直接插入排序的思想对分组数据进行排序
        for i in range(len(nums) - 1):

            for j in range(i, -1, -1):

                if nums[j] > nums[j + 1]:
                    nums[j], nums[j + 1] = nums[j + 1], nums[j]
    # while循环条件折半
        l = int(l/2)
    return nums

快速排序

快速排序首先得选取一个基准值，这个代码用第一个数作为基准值，将比基准值小的值放到左边，比基准值大的值放到右边，随后再将左边后右边按照上述方法进行排序，直到完全正确为止

# 实现快速排序方法的函数
def quick_sort_num(nums,start,end):
    if start < end:
    	# 定义基准值为第一个数
        i, j, pivot = start, end, nums[start]
        while i < j:
        	# 将基准数右边的数中比基准数小的放到左边
            while i < j and nums[j] >= pivot:
                j = j-1
            if i < j:
                nums[i] = nums[j]
                i = i+1
            # 将基准数左边的数中比基准数大的数放到右边
            while i < j and nums[i] < pivot:
                i = i+1
            if i < j:
                nums[j] = nums[i]
                j = j-1
        nums[i] = pivot
        # 分别将基准数左边的数列和右边的数列进行递归
        quick_sort_num(nums, start, i-1)
        quick_sort_num(nums, i+1, end)
    return nums

# 快速排序主体函数
def quick_sort(nums):
    start = 0
    end = len(nums)-1
    nums = quick_sort_num(nums, start, end)
    return nums

print(quick_sort([45, 32, 8, 33, 12, 22, 19, 97]))

冒泡排序

冒泡排序是最简单的排序，依次将左右俩个元素进行比较，每次比较完最后的一个数必定是最大的，依次推类，直到全部元素都比较玩

def bubble_sort(nums):
	# 交换的轮数
    for i in range(len(nums) - 1):
    	# 每一轮交换
        for j in range(len(nums) - i - 1):
        	# 比较值，并根据大小进行互换
            if nums[j] > nums[j + 1]:
                nums[j], nums[j + 1] = nums[j + 1], nums[j]

    return nums

print(bubble_sort([45, 32, 8, 33, 12, 22, 19, 97]))

时间测试

我们先创建一个列表，列表中有10000条数据，随后用相同的数据进行测试

import random
lis = []
for i in range(10000):
    i = random.randint(0,500)
    lis.append(i)

print(lis)

创出来的数据就不进行展示了。。

随后我们进行测试：

冒泡排序法：11.535502672195435

直接插入排序法：12.057243585586548

希尔排序法：86.3020749092102（大概是我的方法不大好吧，我差点以为他排不出来了）

基数排序法：0.051932334899902344（老大哥就是牛皮）

归并排序法：0.08577108383178711（233）

快速排序：0.04795527458190918

堆排序：0.09175491333007812

根据自己的测试，基数排序，归并排序，快速排序，和堆排序速度很快，感觉随着代码量的增长时间增长很慢，其余的几个则不尽如人意了