Zusammenfassung des grundlegenden Sortieralgorithmus von Python (Prüfung zum Basic Information Engineer)

insertsort.py

#
M = [0] * 5
N = 0
J = 0
BUF = [4,2,5,1,3]
for i in range(0,5,1):
    I =0
    while I <=N and M[I] > BUF[i]:
        I = I+1
    J = N
    while J >= I:
        M[J] =M[J-1]
        J = J-1
    M[I] = BUF[i]
    N = N + 1
print(M)
#==[5,4,3,2,1]

bubblesort.py

A = [4,2,5,1,3,6,8,7,6,]
N =len(A)
for i in range(N,1,-1):

    for k in range(0,i-1,+1):
        if A[k] > A[k+1]:
            work = A[k]
            A[k] = A[k+1]
            A[k+1] = work
print(A)
#==[1,2,3,4,5,6,7,8]

Sortierergebnis einfügen Sortierergebnis einfügen Blasensortierung Ergebnis Serktionssortierung

selctionsort.py

A =[5,4,2,1,3]
N =4

for I in range(N,0,-1):
    MAX = I
    for J in range(I-1,-1,-1):
        if A[MAX] < A[J]:
            MAX = J
    work = A[I]
    A[I] = A[MAX]
    A[MAX] = work
print(A)
#Ergebnis== [1,2,3,4,5]

Muschelsort

shellsort.py

H  = [2,1,3,8,6]

k = (len(H))// 2
u =0
while k != 0:
    s = k
    while s <= len(H)-1:
        u = s - k #
        while u >=0:
            if H[u] > H[u+k]:
                print(H)
                work = H[u]
                H[u] = H[u+k]
                H[u+k] = work
                u = u - k
            else:
                break

        s = s + 1

    k = k // 2
print(H)
#Ergebnis==[1,2,3,4,5]

Haufen sortieren

heapsort.py

#Haufen sortieren
A = {1:20,2:50,3:10,4:30,5:70,6:40,7:60,8:80}

def INSERT(i):
    num = N # 2
    o = 1
    while  o != 0:
        o = num // 2 # 1
        if A[num] > A[o]:
            work = A[num]
            A[num] = A[o]
            A[o] = work
            num = o
        if A[num] <= A[o]:
            o -=1


    return A


for N in range(2,9,1):
    hoge = INSERT(N)
print ('Ergebnis der Heap-Erstellung')
print(hoge)


def heap (hani):#7
    oya = 1
    kodo = oya * 2 #2
    while  kodo < hani: #2>7 Rekonstruktionsschleife
        if kodo+1 <= hani: #3<7
            if hoge[kodo+1] > hoge[kodo]:#60 > 70
                kodo+=1

        if hoge[kodo] > hoge[oya]: #3[60] > 2[70]
            work = hoge[kodo]
            hoge[kodo] = hoge[oya]
            hoge[oya] = work
            oya = kodo
            kodo = oya*2
        elif hoge[kodo] <= hoge[oya]:
             kodo = hani + 1

    return hoge


for s in range(len(hoge),2,-1):
    work = hoge[1]
    hoge[1] = hoge[s]
    hoge[s] = work
    #print(hoge)
    if s > 2:
        hoge= heap(s-1)
print ('Sortieren Sie die Heap-Sortierung in aufsteigender Reihenfolge')
print(hoge)
#Ergebnis
#Ergebnis der Heap-Erstellung
#[1: 80, 2: 70, 3: 60, 4: 50, 5: 30, 6: 10, 7: 40, 8: 20]
#[1: 10, 2: 20, 3: 30, 4: 40, 5: 50, 6: 60, 7: 70, 8: 80]

Zusammenführen, sortieren

margesort.py

 #-*- coding: utf-8 -*-
output =[47,33,68,55,74,89,25,10]

span_size =2 #Stellen Sie den Teilungsbereich ein
size = len(output)#Ersetzen Sie die Anzahl der Ausgabeelemente
size2 = size // 2
temp = [0]*size2    #Legen Sie die Größe des Arrays fest, das zum Ersetzen verwendet wird

while span_size <= size: #Nach dem Sortieren des Teilungsbereichs ausführen,Geben Sie den Array-Bereich an ➀
    span_idx = 0 #Initialisieren#Geben Sie die zu teilende Position an
    write_idx = 0#Initialisieren#Wert tauschen
    while span_idx < size: #Stellen Sie die Teilungsposition ② ein
        a_idx = span_idx #Vergleichen Sie die Elemente des geteilten Bereichs
        b_idx = span_idx + span_size // 2 #Stellen Sie das Vergleichsziel innerhalb des geteilten Bereichs ein

        for i in range(a_idx - span_idx,b_idx - a_idx,1): #Stellen Sie die zu ersetzenden Elemente ein ③
            temp[i] = output[i+span_idx]
            #print(temp)
            #print('Zur Array-Temperatur hinzufügen')
            a_yet = True
            b_yet = True
        while a_yet == True or b_yet == True:#Die Schleife endet, wenn die Sortierung innerhalb des Teilungsbereichs abgeschlossen ist ④
            if b_yet == False or (a_yet == True and b_yet == True and temp[a_idx - span_idx] <= output[b_idx]):#⑤
                #Kurzschlussauswertung

                output[write_idx] = temp[a_idx - span_idx]
        
                a_idx +=1

                if a_idx >= span_idx + span_size // 2:
                    a_yet = False
 
            else:

                output[write_idx] = output[b_idx]

                b_idx +=1

                if b_idx >= span_idx + span_size:#Wenn alle Elemente der Array-Temperatur ausgerichtet sind ⑥
                    b_yet = False

            write_idx+=1  #Zählen Sie die Substitutionsposition

        span_idx = span_idx + span_size#Wechseln Sie nach dem Sortieren zum nächsten Scanbereich

    span_size = span_size * 2#



print(output)

#Ergebnis==[10,25,33,47,55,68,74,89]

Schnelle Sorte

quicksoet.py

#Array-Sortierung mit schneller Sortierung
#Sortiermethode, die den Referenzwert bestimmt und in mehr oder weniger unterteilt
#Rekursive Funktion

A = [2,4,221,5,8,2,9,10]
K = 0
J = 0
def Arrange(A,min,max,pivot):
    L = min
    R = max
    while L <= R:
        tmp = A[L]
        A[L] = A[R]
        A[R] = tmp
        while A[L]< pivot:
            L+=1
        while A[R]>= pivot:
            R -=1

    ret = L
    return ret

def findpivot(A,min,max):
    pivot = A[min]
    K  = min+1
    ret = -1
    found = False
    while K <= max and not found:
         if A[K] == pivot:
             K+=1
         else:
             found = True
             if A[K]> pivot:
                 ret = K
             else:
                 ret = min
    return ret

def quicksort(A,min,max):
    J=findpivot(A,min,max)
    if J > -1:
        pivot = A[J]
        K = Arrange(A,min,max,pivot)
        L = K - 1
        quicksort(A,min,L)
        quicksort(A,K,max)
        return(A)

num = quicksort(A,0,len(A)-1,)
print(num)

#Ergebnis[2,2,4,5,8,9,10,221]

Wenn ich jetzt darüber nachdenke, ist es ein Spaghetti-Code ... Es tut mir leid, wenn ich mich nicht darauf beziehen kann.