python排序算法总结

#冒泡排序,比较相邻元素
def Bubble_Sort(lis):
    for i in range(len(lis)):
        t=0
        for j in range(len(lis)-i-1):
            if lis[j]>lis[j+1]:
                lis[j],lis[j+1]=lis[j+1],lis[j] 
                t+=1
        if t==0:return lis        #没有进行过交换，排序结束
    return lis

#选择排序,每次选择最小值放到前面，选择len(lis)-1趟
def Selection_Sort(lis):
    for i in range(len(lis)):
        for j in range(i+1,len(lis)):
            if (lis[i]>lis[j]):
                lis[i],lis[j]=lis[j],lis[i]
    return lis

#插入排序
def Insert_Sort(lis):
    for i in range(len(lis)):
        for j in range(i):
            if lis[i]<lis[j]:
               lis.insert(j,lis.pop(i))
               break
    return lis

#希尔排序
def Shell_Sort(lis,gap_lis):
    for gap in gap_lis:        
        for i in range(gap):            
            lis[i%gap:len(lis):gap]=Insert_Sort(lis[i%gap:len(lis):gap])  
    if 1 not in gap_lis:
        Insert_Sort(lis) 
    return lis    

#归并排序
def Merge_Sort(lis):
    def merge_lis(lis_l,lis_r):
        lis=[]
        while len(lis_l) and len(lis_r):
            if lis_l[0]<=lis_r[0]:
                lis.append(lis_l.pop(0))
            elif lis_l[0]>lis_r[0]:
                lis.append(lis_r.pop(0))
        if len(lis_r)!=0:
            lis.extend(lis_r)
        elif len(lis_l)!=0:
            lis.extend(lis_l)
        return lis
    def recursive(lis):
        if len(lis)==1:
            return lis
        mid=len(lis)//2
        lis_l=recursive(lis[:mid])
        lis_r=recursive(lis[mid:])
        return merge_lis(lis_l,lis_r)
    return recursive(lis)

#快速排序
def Quick_Sort(lis):
    def recursive(begin,end):
        if begin>end:
            return
        l,r=begin,end
        pivot=lis[l]
        while l<r:
            while l<r and lis[r]>=pivot:
                r-=1
            lis[l]=lis[r]
            while l<r and lis[l]<=pivot:
                l+=1
            lis[r]=lis[l]
        lis[l]=pivot
        recursive(begin,l-1)
        recursive(r+1,end)
    recursive(0,len(lis)-1)
    return lis

 #堆排序
def Heap_Sort(lis):    
    def Heap_Adjust(parent):
        child=parent*2+1   #left child ,because parent from 0
        while child<len(heap):
            if child+1<len(heap) and heap[child+1]>heap[child]:
                child+=1
            if heap[parent]>=heap[child]:
                break
            heap[parent],heap[child]=heap[child],heap[parent]
            parent,child=child,child*2+1
    heap,lis=lis.copy(),[]
    for i in range(len(heap)//2,-1,-1):
        Heap_Adjust(i)
    while len(heap)!=0:
        heap[0],heap[-1]=heap[-1],heap[0]
        lis.insert(0,heap.pop())
        Heap_Adjust(0)
    return lis
   
#计数排序
def Counting_Sort(lis):
    count={key:0 for key in range(min(lis),max(lis)+1)}
    for j in lis:
        count[j]+=1
    return [key for key,value in count.items() for i in range(value)]
  
#基数排序
def Radix_Sort(lis):
    bucket,fre=[[]],0
    while len(bucket[0])!=len(lis): #lis中所有值的最高位的再高一位都是0
        bucket=[[],[],[],[],[],[],[],[],[],[]]
        for i in range(len(lis)):
            num=(lis[i]//10**fre)%10      #lis[i] 第fre位的值
            bucket[num].append(lis[i])
        lis.clear()
        for i in range(len(bucket)):
            lis+=bucket[i]
        fre+=1
    return lis