排序算法 python3 冒泡 选择 插入 希尔 归并 快排 堆排序 计数 桶排序 基数排序

冒泡排序

def mp_sort(arr):
    '''
    冒泡排序
    '''
    for i in range(0,len(arr)-1):
        for j in range(0,len(arr)-1-i):
            if arr[j] > arr[j+1]:
                arr[j],arr[j+1] = arr[j+1],arr[j]

选择排序

def sel_sort(arr):
    '''
    选择排序
    '''
    for i in range(0,len(arr)-1):
        x,min_ = i,arr[i]
        for j in range(i+1,len(arr)):
            if arr[j] < min_:
                x = j
                min_ = arr[j]
        arr[i],arr[x] = arr[x],arr[i]

插入排序

def insert_sort(arr):
    '''
    插入排序
    '''
    for i in range(1,len(arr)):
        val = arr[i]
        j = i-1
        while j > -1 and val <= arr[j]:
            arr[j+1] = arr[j]
            j -= 1
        arr[j+1] = val

希尔排序

def shell_sort(arr):
    '''
    希尔排序
    '''
    #先获得递减的增量
    a,shell = len(arr),[]
    while a > 1:
        a //= 2
        shell.append(a)
    #print(shell)
    #i选择shell的值
    for i in shell:
        #j选择要进行插入的值
        for j in range(i,len(arr)):
            val = arr[j]
            k = j-i  #k为左边的插入列表
            while k > -1 and val < arr[k]:
                arr[k+i] = arr[k]
                k -= i
            arr[k+i] = val
        print(f'{i}排序完之后:{arr}')

归并排序

def Merge_sort(arr):
    '''
    归并排序，分治
    '''
    if len(arr) == 1:
        return arr
    mid = len(arr) // 2
    left = Merge_sort(arr[:mid])
    right = Merge_sort(arr[mid:])
    return merge(left,right)

def merge(left,right):
    '''
    归并排序的合并步骤
    '''
    #print(f'此时的left{left},right:{right}')

    a = []
    while len(left)>0 and len(right)>0:
        if left[0] < right[0]:
            a.append(left.pop(0))
        else:
            a.append(right.pop(0))

    if len(left) > 0:
        a.extend(left)

    if len(right) > 0:
        a.extend(right)

    #print(f'a的值:',a)
    return a

快速排序

两个都是，只是实现方法不一样

def quick_sort(arr):
    '''
    快速排序,分治
    '''
    #有可能有空列表的情况，如列表中的值全部为大于a[0]的则，left就为[]
    if len(arr) <= 1:
        return arr
    a = arr[0]
    left,right = [],[]
    for i in range(1,len(arr)):
        if arr[i] > a:
            right.append(arr[i])
        else:
            left.append(arr[i])
    return quick_sort(left) + [a] + quick_sort(right)

def quick_sort2(arr):
    '''
    快速排序，分治
    '''
    if len(arr) <= 1:
        return arr
    mid = 0
    i = 0
    while i < len(arr):
        if arr[i] < arr[mid] and i > mid:
            arr[i],arr[mid] = arr[mid],arr[i]
            mid,i = i,mid
        if arr[i] > arr[mid] and i < mid:
            arr[i],arr[mid] = arr[mid],arr[i]
            mid,i = i,mid
        i += 1
    print(f'左边结果:{arr[:mid]},中间:{arr[mid]},右边:{arr[mid+1:]}')
    return quick_sort2(arr[:mid]) + [arr[mid]] + quick_sort2(arr[mid+1:])

堆排序

def heapify(arr,n,i):
    '''
    调整堆
    '''
    largest = i
    l = 2*i + 1
    r = 2*i + 2

    if l < n and arr[i] < arr[l]:
        largest = l

    if r < n and arr[largest] < arr[r]:
        largest = r

    if largest != i:
        arr[i],arr[largest] = arr[largest],arr[i]

        heapify(arr,n,largest)

def heapSort(arr):
    '''
    堆排序
    '''
    n = len(arr)

    #构建最大堆
    for i in range(n,-1,-1):
        heapify(arr,n,i)

    #然后把最后一个元素和第一个元素交换位置，然后在除了最后一个位置的剩余空间，重新构建最大堆,类推，知道第一个元素，结果就为升序排序
    for i in range(n-1,0,-1):
        arr[i],arr[0] = arr[0],arr[i]
        heapify(arr,i,0)

计数排序

def count_sort(arr):
    '''
    计数排序
    '''
    min_,max_ = min(arr),max(arr)
    base = max_ - min_ + 1 #确定列表需要多少项目
    temp = [0 for i in range(base)]
    #添加的计数l用的列表
    for i in arr:
        temp[i-min_] += 1
    #返回到结果
    rel = []
    for i in range(len(temp)):
        while temp[i] > 0:
            rel.append(i+min_)
            temp[i] -= 1
    return rel

桶排序

def BucketSort(arr):
    '''
    桶排序
    '''
    min_,max_ = min(arr),max(arr)
    base = 5
    index_base = max_//5
    #创建桶列表，里面是5个空列表，表示对应索引的桶
    a = [[] for i in range(base+1)]
    for i in arr:
        a[i//index_base].append(i)

    #对每个桶里面的元素进行排序，可以使用任意其他的排序
    for i in range(len(a)):
        if len(a[i]) <= 1:
            continue
        a[i] = count_sort(a[i])
    #输出每个桶
    print(f'现在桶里是这样的:{a}')
    #合并每个桶，放入到结果列表中
    rel = []
    for i in a:
        rel.extend(i)

    return rel

基数排序

def RadixSort(arr):
    '''
    基数排序
    '''
    max_ = max(arr)
    max_bit = len(str(max_)) #获得最大值有多少位
    radix = arr #存储根据哪个位数来存储s的数组
    temp = [[] for i in range(10)] #临时存储s的

    for i in range(max_bit):
        #根据位数来排序(即比较个位，十位等,放在temp
        for j in radix:
            a = j//10**i % 10
            temp[a].append(j)
        #把排序的一次结果，存到radix中
        radix = [] #先重置一下
        for k in temp:
            radix.extend(k)
        temp = [[] for i in range(10)] #重新恢复
        print(f'第{i}位数，排序后结果:{radix}')
    return radix