10 大基本排序 --python

1 冒泡：相邻的元素作比较

def bubble_sort(num):
    for i in range(1,len(num)-1):
        for j in range(len(num)-i):#后面的i个排序已完成了，不用再排了
            if num[j]>num[j+1]:
                num[j],num[j+1] = num[j+1],num[j]
    return num
nums = [2, 6, 8, 5, 1, 4, 9, 3, 7]
bubble_sort(nums)

2 选择排序：每次从列表中选择一个最大的

def choose_sort(num):
    length = len(num)-1
    while length:
        index = length
        for j in range(length):
            if num[j]> num[index]:
                index = j
        num[length],num[index] = num[index],num[length]
        length -= 1
    return num
            
nums = [2, 6, 8, 5, 1, 4, 9, 3, 7]
choose_sort(nums)

3 插入排序：有序的列表插入元素

def insert_sort(num):
    for i in  range(1,len(num)):
        for j in range(i):
            if num[i]< num[j]:
                num[i],num[j] = num[j],num[i]
    return num
            
nums = [2, 6, 8, 5, 1, 4, 9, 3, 7]
insert_sort(nums)   

 4 希尔排序:增量为k的排序

def shell_sort(num):
    N = len(num)
    k = N//2
    while k>0:
        #从第k个元素开始，逐个对其所在组进行直接插入排序
        i = k
        while i < N:
            j = i-k
            tmp = num[i]
            while j >= 0 and num[j] > tmp:#插入排序
                num[j + k] = num[j]
                j -= k
            num[j+k] = tmp
            i += 1
        k //= 2
                
    return num
            
nums = [2, 6, 8, 5, 1, 4, 9, 3, 7]
shell_sort(nums)      
        

 5 归并排序  分治策略

def merage_sort(nums):
    if len(nums) <= 1:
        return nums
    length = int(len(nums)//2)
    left = merage_sort(nums[:length])
    right= merage_sort(nums[length:])
    return Merge(left,right)
def Merge(left,right):
#     print("left:",left,"right",right)
    l,r = 0,0
    result = []
    
    while l < len(left) and r < len(right):
        if left[l] < right[r]:
            result.append(left[l])
            l += 1
        else:
            result.append(right[r])
            r += 1
    result += left[l:]
    result += right[r:]
#     print("result",result)
    return result
nums = [2, 6, 8, 5, 1, 4, 9, 3, 7]
merage_sort(nums) 

6 快速排序  关键字排序  递归  反复使用分治，分治是一种思想，递归是一种手段

def quick_sort(num,start,end):
    left = start
    right = end
    while left >= right:
        return
    temp = num[left]
    while left < right:
        while temp <= num[right]:
            right -= 1
        num[left]=num[right]
        while left < right and num[left] <= temp:
            left += 1
        num[right]=num[left]
    num[left] = temp
    quick_sort(num,start,left-1)
    quick_sort(num,left+1,end)
    return num
            
nums = [2, 6, 8, 5, 1, 4, 9, 3, 7]
left = 0
right = len(nums)-1
quick_sort(nums,left,right)  
            

7 堆排序

def maxhead_sort(num):
    #构建大顶堆
    for start in range((len(num)-2)//2,-1,-1):
        #从第一个非叶子结点从下至上，从右至左调整结构
        sitdown(num,start,len(num)-1)
        
    for end in range(len(num)-1,0,-1):
        #调整堆结构，交换堆顶元素与末尾元素，使末尾元素最大
        num[0],num[end] = num[end],num[start]
        #重新对堆进行调整
        sitdown(num,0,end-1)
    return num

def sitdown(num,start,end):
    root = start#取出当前元素
    while True:
        child = 2*root+1
        if child > end:
            break
        #如果左子节点小于右子节点，child指向右子节点
        if child+1 <= end and num[child] < num[child+1]:
            child += 1
        #如果子节点大于父节点，将子节点与父节点交换
        if num[root] < num[child]:
            num[root],num[child] = num[child],num[root]
            root = child
        else:
            break
nums = [2, 6, 8, 5, 1, 4, 9, 3, 7]
merage_sort(nums) 

8 计数排序

def Count_sort(num):
    max_num = max(num)
    length = len(num)
    output = [0 for i in range(length)]
    count = [0 for i in range(max_num+1)]
    
    #统计每个元素的出现次数
    for j in num:
        count[j] = count[j]+1

    #对所有的计数累加
    for i in range(1,len(count)):
        count[i] = count[i] + count[i-1]
    print("count",count)
    
    for j in num:
        #直接把元素放在输出列表中
        output[count[j] - 1] = j
        count[j] = count[j] - 1
#         print("huhu",count)
    return output
nums = [2, 6, 8, 5, 1,5, 4, 9, 3, 7,11]
Count_sort(nums) 

9 桶排序 计数排序的映射关系

def Buket_Sort(num):
    buckets = [0] * ((max(num)-min(num))+ 1)
    for i in range(len(num)):
#         print(num[i]-min(num),num[i],min(num))
        buckets[num[i]-min(num)] += 1#遍历num,在桶相应位置累加值,没有出现则为0
    res = []
    print("buckets",buckets)
    for i in range(len(buckets)):
        if buckets[i] != 0:#如果不是空桶，则取出桶的数据
            res  += [i + min(num)] * buckets[i]
    return res
        
nums = [2, 6, 8, 5, 1,5, 4, 9, 3, 7,11]
Buket_Sort(nums)         

10  基数排序

def Radix_nums(num):
     #寻找序列中最大的数
    max_num = num[0]
    for i in range(1,len(num)):
        if max_num < num[i]:
            max_num = num[i]
    max_length = len(str(max_num))
    return max_length

#从低到高的第pos位数
def get_num_pos(num,pos):
    return (int(num/(10 ** (pos-1))))%10

def Radix_Sort(num):
   count = 10 * [None]#存放各个桶的数据统计个数
   bucket = len(num) * [None]#暂时存放的排序结果
   #从低位到高位依次循环执行
   for pos in range(1,Radix_nums(num)+1):
        #置空各个桶的数据
        for x in range(10):
            count[x]=0
        #统计当前该位的元素数目（个位、十位、百位）
        for x in range(0,len(num)):
            #统计各个桶将要放进去的元素个数
            j = get_num_pos(int(num[x]),pos)
            count[j] += 1
            
        #count[i]表示第i个桶的右边界的索引
        for x in range(1,10):
            count[x] += count[x-1]
        print(x,count)
        
        #将数据依次放入桶中
        for x in range(len(num)-1,-1,-1):
            #求出元素第k位的数字
            j = get_num_pos(num[x],pos)
#             print(num[x],pos,j)
            #放入对应的桶中，count[j]-1是第j个桶的右边索引
            bucket[count[j]-1] = num[x]
            #对应桶的装入数据索引-1
            count[j] -= 1
        #将已经分配好的数据再倒出，此时已是对应当前位数有序的表
        for x in range(0,len(num)):
            num[x] = bucket[x]
        print(num)
#         return num
nums = [2, 6, 88, 55, 1,5, 4, 91, 3, 7]
Radix_Sort(nums)          

参考文献：

https://blog.csdn.net/jiaoyangwm/article/details/81807774   代码

https://www.cnblogs.com/onepixel/p/7674659.html    图解+代码

https://www.cnblogs.com/chengxiao/p/6194356.html