Sortメソッドの--python

1、バブルソート（バブルソート）

隣接する要素の比較。最初は、それらの両者を交換するために、第二よりも大きい場合。
私たちは、最初から最後のペアの最初の終わりには、隣接する要素のペアごとに同じ作業を行い、そのためには、最後の要素は、最大数であるべきです。
最後の1を除いて、すべての要素について、上記の手順を繰り返します。
ソートが完了するまで3に、手順1を繰り返します。

DEF バブルソート（LST）：
    N = LEN（LST）
     であれば、N <= 1 ：
         戻りLST
     用 I における範囲（0、N）
         のための J での範囲（0、NI-1 ）：
             もし LST [J]> LST [ J + 1 ]：
                （LST [J]、LST [J +1）=（LST [J + 1 ]、LST [J]）
     戻り LST

2、クイックソート（クイックソート）

シリーズからの1つの要素を選択、「基準」（ピボット）と呼ばれます。
列を並べ替え、基準値よりも小さいベースの前方に配置されているすべての要素は、すべての要素が基準値よりも大きいベースラインの背後に配置され（同じ番号はどちら側でもよいです）。パーティション終了後、中間位置の列の数に基づいて。これは、パーティション（パーティション）動作と呼ばれます。
再帰的に（これを再帰的）基準値よりも小の数が列の数とサブエレメントは、エレメント列の基準値よりも大きいです。

DEF クイックソート（LST）は：
     ＃これは機能分割である
    DEFのパーティション（ARR、左、右）：
        キー =左   ＃は、参照インデックス番号を分割し、最初の数が基準のデフォルトの数である、あなたは、最適化することができます
        しばらくは <左、右：
             ＃場合出現回数の基準数よりも少ないがあるまで番号リストを後ろに、参照番号又は等しいより大きい、その後いずれかで上に移動
            しながら左<右および ARR [右]> = ARR [キー]：
                右 - = 1
             ＃場合は、リストの前面外観の基準数よりも大きい数まで後方に等しい又は基準数よりも少ない数、
            一方は左<右および ARR [左] <= ARR [キー]：
                左 + = 1つの。
             ＃をこの時点で見つけること参考書、およびベンチマークよりも少ない数よりも多い、彼らは場所を切り替えます
            （ARR [左]、ARR [右]）= （ARR [右]、ARR [左]） 
 
        ＃終了位置は2に等しくなるまで小さな基準交換して、それぞれ、両側から左側に接近する場合 
        （左[ARR ]、ARR [キー]）= （ARR [キー]）[] ARR左
         ＃はインデックス参照の現在位置を返す
        リターンが左
 
    DEF （クイックソートをARR、左、右）：  
         IF > =左：右
             戻り
        位ベースライン開始からパーティション 
        MID = パーティション（ARR、左、右）
         ＃再帰呼び出し
        ＃1 印刷（ARR） 
        -クイック（1 ARR、左、MID ）
        クイックソート（ARR、MID + 1。 、右）
 
    ＃main関数 
    N =LEN（LST）
     であれば、N <= 1 ：
         戻りLST 
    クイックソート（LST、0、nは - 1 ）
     戻り LST

3、挿入ソート（挿入ソート）

ソートされていると考えることができ、最初の要素で始まります。
前方スキャンから次の要素を削除する要素の順序でソートされています。
要素（ソート）は、新しい要素、次の位置への要素よりも大きい場合。
ステップ3を繰り返し、それは以下の要素の新しい位置に等しいソート要素を見つけるまで。
新しい要素は、この位置に挿入された後。
ステップ2〜5を繰り返します。

def InsertSort(lst):
    n=len(lst)
    if n<=1:
        return lst
    for i in range(1,n):
        j=i
        target=lst[i]            #每次循环的一个待插入的数
        while j>0 and target<lst[j-1]:       #比较、后移，给target腾位置
            lst[j]=lst[j-1]
            j=j-1
        lst[j]=target            #把target插到空位
    return lst

4、希尔排序法(Shell Sort)

选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
按增量序列个数k，对序列进行k 趟排序；
每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

def ShellSort(lst):
    def shellinsert(arr,d):
        n=len(arr)
        for i in range(d,n):
            j=i-d
            temp=arr[i]             #记录要出入的数
            while(j>=0 and arr[j]>temp):    #从后向前，找打比其小的数的位置
                arr[j+d]=arr[j]                 #向后挪动
                j-=d
            if j!=i-d:
                arr[j+d]=temp
    n=len(lst)
    if n<=1:
        return lst
    d=n//2
    while d>=1:
        shellinsert(lst,d)
        d=d//2
    return lst

5、选择排序法(Select Sort)

初始状态：无序区为R[1..n]，有序区为空；
第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
n-1趟结束，数组有序化了。

def SelectSort(lst):
    n = len(lst)
    if n<=1:
        return lst
    for i in range(0,n-1):
        minIndex = i
        for j in range(i+1,n): #比较一遍，记录索引不交换
            if lst[j]<lst[minIndex]:
                minIndex=j
        if minIndex!=i:
            (lst[minIndex],lst[i])=(lst[i],lst[minIndex])
    return lst

6、堆积排序法(Heap Sort)

将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成

def  HeapSort(lst):
    def heapadjust(arr,start,end):  #将以start为根节点的堆调整为大顶堆
        temp=arr[start]
        son=2*start+1
        while son<=end:
            if son<end and arr[son]<arr[son+1]:  #找出左右孩子节点较大的
                son+=1
            if temp>=arr[son]:       #判断是否为大顶堆
                break
            arr[start]=arr[son]     #子节点上移
            start=son                     #继续向下比较
            son=2*son+1
        arr[start]=temp             #将原堆顶插入正确位置
#######
    n=len(lst)
    if n<=1:
        return lst
    #建立大顶堆
    root=n//2-1    #最后一个非叶节点（完全二叉树中）
    while(root>=0):
        heapadjust(lst,root,n-1)
        root-=1
    #掐掉堆顶后调整堆
    i=n-1
    while(i>=0):
        (lst[0],lst[i])=(lst[i],lst[0])  #将大顶堆堆顶数放到最后
        heapadjust(lst,0,i-1)    #调整剩余数组成的堆
        i-=1
    return lst

7、归并排序法(Merge Sort)

把长度为n的输入序列分成两个长度为n/2的子序列；
对这两个子序列分别采用归并排序；
将两个排序好的子序列合并成一个最终的排序序列

def MergeSort(lst):
    #合并左右子序列函数
    def merge(arr,left,mid,right):
        temp=[]     #中间数组
        i=left          #左段子序列起始
        j=mid+1   #右段子序列起始
        while i<=mid and j<=right:
            if arr[i]<=arr[j]:
                temp.append(arr[i])
                i+=1
            else:
                temp.append(arr[j])
                j+=1
        while i<=mid:
            temp.append(arr[i])
            i+=1
        while j<=right:
            temp.append(arr[j])
            j+=1
        for i in range(left,right+1):    #  !注意这里，不能直接arr=temp,他俩大小都不一定一样
            arr[i]=temp[i-left]
    #递归调用归并排序
    def mSort(arr,left,right):
        if left>=right:
            return
        mid=(left+right)//2
        mSort(arr,left,mid)
        mSort(arr,mid+1,right)
        merge(arr,left,mid,right)
 
    n=len(lst)
    if n<=1:
        return lst
    mSort(lst,0,n-1)
    return lst

8、基数排序法(Radix Sort)

取得数组中的最大数，并取得位数；
arr为原始数组，从最低位开始取每个位组成radix数组；
对radix进行计数排序（利用计数排序适用于小范围数的特点）；

import math
def RadixSort(lst):
    def getbit(x,i):       #返回x的第i位（从右向左，个位为0）数值
        y=x//pow(10,i)
        z=y%10
        return z
    def CountSort(lst):
        n=len(lst)
        num=max(lst)
        count=[0]*(num+1)
        for i in range(0,n):
            count[lst[i]]+=1
        arr=[]
        for i in range(0,num+1):
            for j in range(0,count[i]):
                arr.append(i)
        return arr
    Max=max(lst)
    for k in range(0,int(math.log10(Max))+1):             #对k位数排k次,每次按某一位来排
        arr=[[] for i in range(0,10)]
        for i in lst:                 #将ls（待排数列）中每个数按某一位分类（0-9共10类）存到arr[][]二维数组（列表）中
            arr[getbit(i,k)].append(i)
        for i in range(0,10):         #对arr[]中每一类（一个列表）  按计数排序排好
            if len(arr[i])>0:
                arr[i]=CountSort(arr[i])
        j=9
        n=len(lst)
        for i in range(0,n):     #顺序输出arr[][]中数到ls中，即按第k位排好
            while len(arr[j])==0:
                j-=1
            else:
                lst[n-1-i]=arr[j].pop()   
    return lst

转载链接：https://blog.csdn.net/weixin_41571493/article/details/81875088

おすすめ