Eine Blasensortierung
Bubble-Sort-Algorithmus arbeitet wie folgt:
Vergleichen Sie benachbarte Elemente. Wenn die erste größer als die zweite ist, ausgetauscht die zwei von ihnen.
Die gleiche Arbeit für jedes Paar benachbarter Elemente, vom Anfang bis zum Ende der ersten bis zum letzten Paar. Sobald dies geschehen ist, ist das letzte Element die größte Zahl.
Wiederholen Sie diese Schritte für alle Elemente, mit Ausnahme des letzten.
Fortsetzung der obigen Schritte für jedes Mal , immer weniger Elemente, ein Paar von Zahlen zu wiederholen , bis es keine Notwendigkeit zu vergleichen ist.
Above Auszug aus Wikipedia
Code-Implementierung:
def bubble_sort (Nummer Liste ):
Länge = Len (Nummer Liste )
für i im Bereich (Länge):
für j im Bereich (1, Länge - i):
wenn Nummer Liste [j - 1]> Nummer Liste [j]:
Nummer Liste [j], Nummer Liste [j - 1] = Nummer Liste [j - 1], Nummer Liste [j]
Rückkehr Nummer Liste
二,选择排序
Selection Sort (Auswahl Sortierung) ist ein einfacher Sortieralgorithmus. Es funktioniert wie folgt. Zuerst findet die kleinste Sequenz von unsortiert (large) Elemente wird die Startposition in der sortierten Folge gespeichert ist, und dann weiter das Minimum (large) Element von den restlichen Elementen unsortierter und sortierte in das Ende der Sequenz zu finden. Und so weiter, bis alle Elemente sortiert.
Above Auszug aus Wikipedia
Code-Implementierung:
def findSmallest (arr): # das kleinste Element in der Anordnung , um herauszufinden, gibt den Index des kleinsten Elements.
Kleinste ARR = [0]
smallest_index = 0
für I im Bereich (1, Len (ARR).):
IF Kleinster> ARR [I]:
Kleinste ARR = [I]
smallest_index = I
zurückkehren smallest_index
def SelectSort (arr):
newArr = [] ,
während arr:
kleinste = findSmallest (arr)
newArr.append (arr.pop (kleinste))
return newArr
Drittens Insertionsort
Treppe
Beginnend mit dem ersten Elemente, die in Betracht gezogen werden kann , um sortiert wurden
holt das nächste Element aus der Vorwärtsabtastung in der Reihenfolge von Elementen in angeordnet worden ist ,
wenn das Element (sortiert) größer ist als das neue Element, das Element in die nächsten Position
wiederholen Sie Schritt 3 , bis Sie die Position der sortierten Elemente weniger finden als oder auf das neue Element gleich
nachdem das Element in die neue Position eingeführt wird ,
wiederholen Sie die Schritte 2-5
oben Auszug aus Wikipedia
Code-Implementierung
def insert_sort (data):
für k im Bereich (1, Len (Daten)):
cur = data [k]
j = k ,
während j> 0 und data [j - 1]> cur:
data [j] = data [j - 1]
j - = 1
data [j] = cur
Rückgabedaten
四,希尔排序
Shellsort durch alle Elemente verglichen werden soll, in mehrere Bereiche unterteilt Leistung Insertionsort zu verbessern. Dies erlaubt ein einmaliges Element kann ein großer Schritt vorwärts in Richtung der Endposition. Der Algorithmus dann mehr und nimmt kleine Schritte zu sortieren, ist der letzte Schritt ist ein gewöhnlicher Insertionsort-Algorithmus, aber zu diesem Schritt müssen Sie die Daten bereits fast einen guten (diesmal Insertionsort schneller) gebucht worden waren, sortieren.
Above Auszug aus Wikipedia
Code-Implementierung:
def shell_sort (Nummer Liste ):
Länge = Len (Nummer Liste )
gap = Länge // 2
während gap> 0:
für i im Bereich (Spalt, Länge):
temp = Nummer Liste [i]
j = i ,
während j> = Lücke und Nummer Liste [ j - Lücke]> Temp:
Nummer Liste [j] = Nummer Liste [j - gap]
j - = Lücke
Nummer Liste [j] = Temp
gap = Lücke // 2
Rückkehr Nummer Liste
五,归并排序
Prinzip ist wie folgt (unter der Annahme Elemente Consensussequenz {displaymath n}):
Die Sequenz von jedem benachbarten zwei Zahlen fusionieren Betrieb eine {displaymath ceil (N / 2) } Sequenzen, wobei jede Sequenz umfassend zwei sortierten / ein Element ,
wenn die Sequenznummer nicht um einen Fall ist die obige Sequenz wieder fusionieren, bilden {displaymath ceil (N / 4) } Sequenzen, wobei jede Sequenz vier / drei Elemente umfasst ,
Schritt 2 wiederholt , bis alle Elemente sortiert, das heißt , die Sequenznummer ist 1
oder mehr Auszug aus Wikipedia
Code ist wie folgt:
def merge (links, rechts):
Ergebnis = [] ,
während links und rechts:
wenn links [0] <right [0]:
result.append (left.pop (0))
sonst:
result.append (right.pop (0 )) ,
wenn links:
Ergebnis + = links ,
wenn rechts:
Ergebnis + = rechts
Rücker
def merge_sort (Nummer Liste ):
If Len (Nummer Liste ) <= 1:
Rückkehr Nummer Liste
mid = len (Nummer Liste ) // 2
links = Nummer Liste [: Mitte]
rechts = Nummer Liste [Mitte:]
left = merge_sort(left)
right = merge_sort(right)
return merge(left, right)
Sechstens schnell sortieren
Auszusuchen die Anzahl der Spalten in einem Element, eine so genannte „Referenz“ (Pivot),
Neuordnen Spalten, die alle kleiner als der Referenzwert wird vor dem Referenzelement angeordnet, die alle größer als der Referenzwert Elemente hinter dem Referenz gelegt (die gleiche Anzahl sein kann auf jeder Seite). Nach dem Ende dieses Bereichs, in einer Zwischenposition auf der Referenzsequenz. Diese Aufteilung wird (Partition) Betrieb genannt.
Rekursives (rekursiven) als der Referenzwert die Zahl der Spalten und das Unterelement größer ist als der Referenzwert der Anzahl Spaltengeordnetes Element.
Rekursive nach unten, ist die Größe die Anzahl der Spalten oder eine Null, die bereits besser sortiert. Dieser Algorithmus wird beendet, weil in jeder Iteration (Iteration), die mindestens ein Element in seiner endgültigen Position gebracht wird , um zu gehen.
Above Auszug aus Wikipedia
Code ist wie folgt:
quick_sort def (Array):
If Len (array) <2:
return array
else:
Dreh = array [0]
weniger = [i für i in array [1:] , wenn i <= Schwenk]
größer = [i für i in array [1:] , wenn i> Dreh]
return quick_sort (weniger) + [Schwenk] + quick_sort (größer)
七,堆排序
In Bezug auf den Anweisungen in aufsteigender Reihenfolge, wobei die Anordnung in die maximalen Stapel (Max-Heap Heap), die eine Bulk-Eigenschaften ist die maximale (Max-Heap-Eigenschaft) eine Binärbaum erfüllen: Für jeden Knoten mit Ausnahme der Wurzel i, A [parent (i)] ≥ A [i].
Wiederholen Sie den maximalen Wert von dem maximalen Stapelknoten genommen (der Wurzelknoten und dem letzten Austausch, der letzten Vermittlungsknoten nach dem Entfernen des Stapels), und so die maximale Akkumulation der Restvolumeneigenschaften beibehalten.
def heap_sort (Nummer Liste ):
Länge = len (Nummer Liste )
def sift_down (Anfang, Ende):
root = beginnen ,
während True:
Kind = 2 * root + 1 ,
wenn das Kind> Ende:
Pause ,
wenn das Kind + 1 <= Ende und Nummer Liste [Kind ] <Nummer Liste [Kind + 1]:
Kind + = 1 ,
wenn Nummer Liste [root] <Nummer Liste [Kind]:
Nummer Liste [root], Nummer Liste [Kind] = Nummer Liste [Kind], Nummer Liste [root]
root = Kind
sonst:
Pause
Erstellen maximale Heap
for start in range((length - 2) // 2, -1, -1):
sift_down(start, length - 1)
Heapsort
for end in range(length - 1, 0, -1):
numberlist[0], numberlist[end] = numberlist[end], numberlist[0]
sift_down(0, end - 1)
return numberlist
Acht, Countingsort
oben Auszug aus Wikipedia -
Code ist wie folgt:
def counting_sort (Nummer Liste , maxNumber): # maxNumber der maximale
Arraylänge = Len (Nummer Liste ) # sortiertes Array Länge sein
[im Bereich 0 für i b = (Länge)] # die Ausgangssequenz gesetzt ist , wird auf 0 initialisiert ,
C = [ 0 für i im Bereich (maxNumber + 1)] # SET - Technologie - Sequenz auf 0 initialisiert ist
für J in Nummer Liste ,:
C [J] = C [J] + 1.
für I im Bereich (1, len ©.):
C [i] = C [i] + C [I -. 1]
für J in Nummer Liste ,:
B [C [J] -. 1] = J
C [J] = C [J] -. 1
return B
diesem Artikel durch Bezugnahme Wikipedia und acht Sortieralgorithmus Python erreichen Compilations
