Python实现十种排序算法

#%%

冒泡排序

1. 算法步骤
   比较相邻的元素。如果第一个比第二个大，就交换他们两个。 # # 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。 # # 针对所有的元素重复以上的步骤，除了最后一个。 # # 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

def bubbleSort(arr):
    for i in range(1, len(arr)):
        for j in range(0, len(arr)-i):
            if arr[j] > arr[j+1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr
nums = [1,3,5,7,2,4,6]
print("排序前:" , nums)
# 传递列表副本排序
print("排序后:",bubbleSort(nums[:]))

#%%

选择排序

1. 算法步骤
   首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置 # # 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。 # # 重复第二步，直到所有元素均排序完毕。

def selectionSort(arr):
    for i in range(len(arr) - 1):
        # 记录最小数的索引
        minIndex = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[minIndex]:
                minIndex = j
        # i 不是最小数时，将 i 和最小数进行交换
        if i != minIndex:
            arr[i], arr[minIndex] = arr[minIndex], arr[i]
    return arr
print("排序前:" , nums)
# 传递列表副本排序
print("排序后:",selectionSort(nums[:]))

插入排序

1. 算法步骤 # # 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。 # # 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

def insertionSort(arr):
    for i in range(len(arr)):
        preIndex = i-1
        current = arr[i]
        while preIndex >= 0 and arr[preIndex] > current:
            arr[preIndex+1] = arr[preIndex]
            preIndex-=1
        arr[preIndex+1] = current
    return arr
print("排序前:" , nums)
# 传递列表副本排序
print("排序后:",insertionSort(nums[:]))

希尔排序

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。 # 但希尔排序是非稳定排序算法。 # 1. 算法步骤 # # 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1； # 按增量序列个数 k，对序列进行 k 趟排序； # 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列， # 分别对各子表进行直接插入排序。 # 仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

def shellSort(arr):
    import math
    gap=1
    while(gap < len(arr)/3):
        gap = gap*3+1
    while gap > 0:
        for i in range(gap,len(arr)):
            temp = arr[i]
            j = i-gap
            while j >=0 and arr[j] > temp:
                arr[j+gap]=arr[j]
                j-=gap
            arr[j+gap] = temp
        gap = math.floor(gap/3)
    return arr
print("排序前:" , nums)
# 传递列表副本排序
print("排序后:",shellSort(nums[:]))

归并排序

1. 算法步骤 # 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列； # 设定两个指针，最初位置分别为两个已经排序序列的起始位置； # 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置； # 重复步骤 3 直到某一指针达到序列尾； # 将另一序列剩下的所有元素直接复制到合并序列尾。

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
print("排序前:" , nums)
# 传递列表副本排序
print("排序后:",mergeSort(nums[:]))

快速排序

1. 算法步骤 # 从数列中挑出一个元素，称为 “基准”（pivot）; # 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作； # 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

def quickSort(arr, left=None, right=None):
    left = 0 if not isinstance(left,(int, float)) else left
    right = len(arr)-1 if not isinstance(right,(int, float)) else right
    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
    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]
print("排序前:" , nums)
# 传递列表副本排序
print("排序后:",quickSort(nums[:]))

堆排序

大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列； # 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列； # 堆排序的平均时间复杂度为 Ο(nlogn)。 # 1. 算法步骤 # 创建一个堆 H[0……n-1]； # 把堆首（最大值）和堆尾互换； # 把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置； # 重复步骤 2，直到堆的尺寸为 1。

def buildMaxHeap(arr):
    import math
    for i in range(math.floor(len(arr)/2),-1,-1):
        heapify(arr,i)

def heapify(arr, i):
    left = 2*i+1
    right = 2*i+2
    largest = i
    if left < arrLen and arr[left] > arr[largest]:
        largest = left
    if right < arrLen and arr[right] > arr[largest]:
        largest = right

    if largest != i:
        swap(arr, i, largest)
        heapify(arr, largest)

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

def heapSort(arr):
    global arrLen
    arrLen = len(arr)
    buildMaxHeap(arr)
    for i in range(len(arr)-1,0,-1):
        swap(arr,0,i)
        arrLen -=1
        heapify(arr, 0)
    return arr
print("排序前:" , nums)
# 传递列表副本排序
print("排序后:",heapSort(nums[:]))

计数排序

def countingSort(arr, maxValue):
    bucketLen = maxValue+1
    bucket = [0]*bucketLen
    sortedIndex =0
    arrLen = len(arr)
    for i in range(arrLen):
        if not bucket[arr[i]]:
            bucket[arr[i]]=0
        bucket[arr[i]]+=1
    for j in range(bucketLen):
        while bucket[j]>0:
            arr[sortedIndex] = j
            sortedIndex+=1
            bucket[j]-=1
    return arr
print("排序前:" , nums)
# 传递列表副本排序
print("排序后:",countingSort(nums[:],7))

基数排序

def RadixSort(a):
    i = 0                                             #初始为个位排序
    n = 1                                           #最小的位数置为1（包含0）
    max_num = max(a)                       #得到带排序数组中最大数
    while max_num > 10**n:              #得到最大数是几位数
        n += 1
    while i < n:
        bucket = {}                             #用字典构建桶
        for x in range(10):
            bucket.setdefault(x, [])    #将每个桶置空
        for x in a:                               #对每一位进行排序
            radix =int((x / (10**i)) % 10)   #得到每位的基数
            bucket[radix].append(x) #将对应的数组元素加入到相应位基数的桶中
        j = 0
        for k in range(10):
            if len(bucket[k]) != 0:       #若桶不为空
                for y in bucket[k]:         #将该桶中每个元素
                    a[j] = y                       #放回到数组中
                    j += 1
        i += 1
    return a   

if __name__ == '__main__':
    a = [12,3,45,3543,214,1,4553]
    print("排序前:" , a)
    # 传递列表副本排序
    print("排序后:",RadixSort(a))

#%%

桶排序

def bucketSort(nums):
    # 选择一个最大的数
    max_num = max(nums)
    # 创建一个元素全是0的列表, 当做桶
    bucket = [0]*(max_num+1)
    # 把所有元素放入桶中, 即把对应元素个数加一
    for i in nums:
        bucket[i] += 1
 
    # 存储排序好的元素
    sort_nums = []
    # 取出桶中的元素
    for j in range(len(bucket)):
        if bucket[j] != 0:
            for y in range(bucket[j]):
                sort_nums.append(j)
 
    return sort_nums
 
nums = [5,6,3,2,1,65,2,0,8,0]
print("排序前:" , nums)
# 传递列表副本排序
print("排序后:",bucketSort(nums))