希尔排序，归并排序，快速排序，三路排序（python实现）

最新推荐文章于 2021-09-16 16:14:48 发布

原创最新推荐文章于 2021-09-16 16:14:48 发布 · 808 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#排序 #python

本文介绍了四种经典的排序算法——希尔排序、归并排序、快速排序以及三路排序，并提供了每种排序算法的Python实现代码，旨在帮助读者理解并掌握这些排序方法。

希尔排序：

def shellSort(alist):
    gap=len(alist)//2
    while gap>0:
        for startPos in range(gap):
            gapInsertionSort(alist,startPos,gap)
        gap=gap//2
def gapInsertionSort(alist,startPos,gap):
    for i in range(startPos+gap,len(alist),gap):
        position=i
        currentValue=alist[i]
        while position-gap>=0 and alist[position-gap]>currentValue:
                alist[position]=alist[position-gap]
                position=position-gap
        alist[position]=currentValue

归并排序：

def mergeSort(alist):
    if len(alist)>1:
        if len(alist)<=16:
            alist=shellSort(alist) #一个优化，在数组个数比较小时，插入排序比归并排序更快
            return alist
        mid=len(alist)//2
        lefthalf=alist[:mid]
        righthalf=alist[mid:]
        lefthalf=mergeSort(lefthalf)
        righthalf=mergeSort(righthalf)
        if lefthalf[-1]<=righthalf[0]:
            alist=lefthalf+righthalf
            return alist
        i,j,k=0,0,0
        while i<len(lefthalf) and j<len(righthalf):
            if lefthalf[i]<=righthalf[j]:
                alist[k]=lefthalf[i]
                i+=1
            else:
                alist[k]=right[j]
                j+=1
            k+=1
        while i<len(lefthalf):
            alist[k]=lefthalf[i]
            k+=1
            i+=1
        while j<len(righthalf):
            alist[k]=righthalf[j]
            k+=1
            j+=1
    return alist

快速排序：

from random import randint
def quickSort(alist):
    quickSortHelper(alist,0,len(alist)-1)
    return alist
def quickSortHelper(alist,first,last):
    if first<last:
        if last-first<=16:
            insertionSortForQS(alist,first,last)
        else:
            splitpoint=partition(alist,first,last)
            quickSortHelper(alist,first,splitpoint-1)
            quickSortHelper(alist,splitpoint+1,last)
def insertionSortForQS(alist,first,last):
    for i in range(first+1,last+1):
        currentvalue=alist[i]
        position=i
        while alist[position-1]>currentvalue and position>first:
            alist[position]=alist[position-1]
            position=position-1
        alist[position]=currentvalue
    return alist
def partition(alist,first,last):
    rand=randint(first,last) #随机取标定点，解决近乎有序的列表
    alist[first],alist[rand]=alist[rand],alist[first]
    pivotvalue=alist[first]
    leftmark=first+1
    rightmark=last
    dont=False
    while not done:
        while leftmark<=rightmark and alist[leftmark]<pivotvalue:
            leftmark+=1
        while right>=leftmark and alist[rightmark]>pivotvalue:
            rightmark-=1
        if leftmark>rightmark:
            done=True
        else:
            alist[leftmark],alist[rightmakr]=alist[rightmark],alist[leftmark]
            leftmark+=1
            rightmark-=1
    alist[first],alist[rightmark]=alist[rightmark],alist[first]
    return rightmark

三路排序：

def quickSort3Ways(alist):
    quickSortWaysHelper(alist,0,len(alist)-1)
    return alist
def quickSortWaysHelper(alist,first,last):
    if first<last:
        if last-first<=16:
            insertionSortForQS(alist,first,last) #快速排序里面实现了
        else:
            ltEnd,gtStart=partition3Ways(alist,first,last)
            quickSort3WaysHelper(alist,first,ltEnd)
            quickSort3WaysHelper(alist,gtStart,last)
def partition3Ways(alist,first,last):
    rand=randint(first,last)
    alist[first],alist[rand]=alist[rand],alist[first]
    pivolvalue=alist[first]
    It,i,gt=first,first+1,last+1 #固定住第一个元素
    done=False
    while not done:
        if alist[i]<pivolvalue:
            alist[lt+1],alist[i]=alist[i],alist[lt+1] 
            i+=1
            lt+=1
        elif alist[i]==pivolvalue:
            i+=1
        else:
            alist[gt-1],alist[i]=alist[i],alist[gt-1]
            gt-=1
       if i>=gt:
            done=True
    alist[first],alist[lt]=alist[lt],alist[first]
    lt-=1 #lt -1表示的是小于pivoluvalue最大索引
    return lt,gt