排序算法大全——python

import time
import test
#对列表中i,j位置元素实现交换
def swap(List,i,j):
    temp=List[i]
    List[i]=List[j]
    List[j]=temp
#从小到大进行排序
#"冒泡排序的实现"
#最简单的冒泡排序
def BubbleSort1(List):
    start=time.time()
    n=len(List)
    for j in range(n):
        for i in range(n-1):
            if List[i]>List[i+1]:
                swap(List,i,i+1)
    end=time.time()
    return List,(start-end)
#改进的冒泡排序
def BubbleSort2(List):
    start=time.time()
    n=len(List)
    for j in range(n-1):
        for i in range(j+1,n):
            if List[j]>List[i]:
                swap(List,i,j)
    end=time.time()
    return List,(start-end)
#改进的冒泡排序
def BubbleSort3(List):
    start=time.time()
    n=len(List)
    for i in range(n-1):
        for j in range(n-1,i,-1):
            if List[j]<List[j-1]:
                swap(List,j-1,j)
    end=time.time()
    return List,(start-end)
#改进的冒泡排序
def BubbleSort4(List):
    start=time.time()
    n=len(List)
    flag=True
    for i in range(n-1):
        flag=False
        for j in range(n-1,i,-1):
            if List[j]<List[j-1]:
                flag=True
                swap(List,j-1,j)
        if flag==False:
            break
    end=time.time()
    return List,(start-end)
#"选择排序"
def SelectSort(List):
    n=len(List)
    for i in range(n-1):
        min=i
        for j in range(i+1,n):
            if List[min]>List[j]:
                min=j
        if min!=i:
            swap(List,min,i)
    return List
#"直接插入排序"
def StraightInsertSort(List):
    n=len(List)
    for i in range(1,n):
        temp=List[i]#把第i个数放起来
        #比较第i个数和之前数的大小，如果小于之前的数，那么把之前的数的位置往后移动1位
        j=i-1
        while j>=0 and List[j]>temp:
            List[j+1]=List[j]
            j-=1
        List[j+1]=temp#因为while循环里面已经减1了，所以这儿加1才是i的位置
    return List
#希尔排序（直接插入排序的改进版本）
def ShellSort(List):
    n=len(List)
    step=n
    while step>1:
        step=step//3+1
        for i in range(step+1,n):
            if List[i]<List[i-step]:
                temp=List[i]
                j=i-step
                while j>=0 and List[j]>temp:
                    List[j+step]=List[j]
                    j-=step
                List[j+step]=temp
    return List
#堆排序
#构建一个大顶推是从最下面的父节点开始换位置的
#BigHeapAdjust函数调整第s个父节点到合适的位置，如果除过s个节点之外，其余节点保持为大顶推，那么只需要调整这一个元素就行，
# 否则要从最下面的父节点开始调节
def BigHeapAdjust(List,s,m):#s代表List[s]位置的数
    temp=List[s]
    j=2*s+1#获得List[s]左孩子List[2*s+1]
    while j+1<=m:#判断这个孩子的位置是否超出了总的数的大小
        if j+1<m and List[j]<List[j+1]:#左子树小于右子树，如果小于号满足代表该节点有右兄弟，因为它的位置小于m个，则可以进行左右判断
            j+=1
        if  temp>=List[j]:#判断父节点和孩子节点的大小
            break
        List[s]=List[j]
        s=j
        j=2*j+1
    List[s]=temp
    return List
def HeapSort(List):
    n=len(List)
    for i in range(n//2,0,-1):
        BigHeapAdjust(List,i-1,n)#输入的是下标
    for j in range(n-1,0,-1):
        swap(List,j,0)
        BigHeapAdjust(List,0,j)#j代表数据的数量大小
    return List
#归并排序，采用分而治之的思想
def MergeSort1(List):
    if len(List)<=1:
        return  List
    m=len(List)//2
    left=MergeSort1(List[:m])
    right=MergeSort1(List[m:])
    return Merge(left,right)
def Merge(left,right):#将有序的SR[i.....m]和SR[m+1,.....n]归并为有序的TR[i.....n]
    '''合并两个已经排序好的列表'''
    result = []
    i=0
    j=0
    while i<len(left) and j<len(right):
        if left[i]<right[j]:
            result.append(left[i])
            i+=1
        else:
            result.append(right[j])
            j+=1
    result+=left[i:]
    result+=right[j:]
    return result
'''非递归实现归并排序'''
def MergeSort2(List):
    i=1#子数组长度
    while i<len(List):
        low=0
        while low<len(List):
            mid=low+i
            high=min(low+2*i,len(List))
            print ('height',high)
            if mid<high:
                List[low:high]=Merge(List[low:mid],List[mid:high])
            low=low+2*i
        i*=2
    return List
'''快速排序法'''
def FastSort(List):
    low=0
    high=len(List)-1
    FastSort1(List,low,high)
    return List
def FastSort1(List,low,high):
    if (low<high):
        pivot=Partition(List,low,high)
        FastSort1(List,low,pivot-1)
        FastSort1(List,pivot+1,high)
def Partition(List,low,high):
    m=(low+high)//2
    if List[low]>List[high]:
        swap(List,low,high)
    if List[m]>List[high]:
        swap(List,m,high)
    if List[m]>List[low]:
        swap(List,m,low)
    pivotvalue=List[low]
    temp=pivotvalue
    while low<high:
        while low<high and pivotvalue<=List[high]:
            high-=1
        #swap(List,low,high)
        List[low]=List[high]
        while low<high and List[low]<=pivotvalue:
            low+=1
        #swap(List,low,high)
        List[high]=List[low]
    List[low]=temp
    return low
'''计数排序算法'''
def CountingSort(List):
    n=len(List)
    m=max(List)
    B=[0]*n
    #C=[0 for i in range(m+1)]
    C=[0]*(m+1)
    for i in range(n):
        C[List[i]]=C[List[i]]+1
    for j in range(1,m+1):
        C[j]=C[j]+C[j-1]
    for j in range(n-1,-1,-1):
        B[C[List[j]]-1]=List[j]
        C[List[j]]=C[List[j]]-1
    return B
'''基数排序算法'''
def RadixSort(List):
    Big=max(List)
    n=1
    i=0
    while 10**n<=Big:
        n+=1
    while i<n:
        Digit={}
        j=0
        for x in range(10):
            Digit.setdefault(x,[])#初始化字典的每个键值，如果x存在，则返回该键对应的值，否则返回为该键默认设置的[]。
        '''for j in range(m):
            data=int(List[j]/10**i)%10
            Digit[data].append(List(j))  '''
        for x in List:
            data=int((x/(10**i))%10)
            Digit[data].append(x)
        for k in range(10):
            if Digit[k]!=None:
                for x in Digit[k]:
                    List[j]=x
                    j+=1
        i+=1
    return List
'''桶排序算法,输入n个数据是均匀的分布在[0,1）区间上'''
def BucketSort(List):
    n=len(List)
    B=[[] for i in range(n)]
    for i in range(n):
        B[i]=[]
    for j in range(n):
        B[int(n*List[j])].append(List[j])
    j=0
    for i in range(n):
        if B[i]!=None:
            B[i].sort()
            for x in B[i]:
                List[j]=x
                j+=1
    return List

if __name__=="__main__":
    a=[0.5, 0.4, 0.3, 0.1, 0.2, 0.7, 0.5, 0.15,0.9,0.15]
    d = BucketSort(a)
    print(d)