Was ist Quicksort?

Quicksort ist einer der effizienten Sortieralgorithmen. Der Algorithmus führt Sortierung durch, indem die Kluft und das Eroberer -Paradigma angewendet werden. Betrachten Sie ein Array A [1… n] von N -Elementen. Der Algorithmus teilt das Array A auf einen Index Q, so dass alle Elemente im Sub-Array links im Index geringer sind als das Element im Index Q (A [Q]), und alle Elemente im rechten Subtarray sind größer als a [Q]. Jetzt sortiert der Algorithmus die beiden Subtarrays A [1… q-1] und A [Q+1… n] ein, indem Sie die Quicksort-Funktion aufrufen. Um den Index Q zu erhalten, verwendet der Algorithmus eine Partitionsfunktion.

Die Partitionsfunktion ist eine Funktion, die ein Array A [l… u] als Eingabe aufnimmt. Hier, l ist die Untergrenze und u ist die Obergrenze des Arrays. Der Algorithmus findet einen Index Q so dass alle Elemente weniger als ein [q] in die Subtarray A [L… q-1] und alle Elemente, die größer als ein [q] in das Subarray A [Q+1… u] fallen, fallen. Die Partitionsfunktion erreicht dies durch die Verwendung eines Drehelementelements und zwei Zeiger - Zeiger i und Zeiger j auf das Array.

Zeiger j zeigt auf das erste Element im Array, und der Zeiger I wird als J-1 initialisiert. Die Funktion iteriert das Array mit Zeiger J. Für Element A [j] kann das Element größer sein als das Pivot -Element oder weniger als das Pivot -Element. Wenn das Element größer als das Pivot -Element ist, wird Zeiger J erhöht und zeigt auf das nächste Element. Wenn das Element A [j] geringer ist als das Pivot -Element, erhöhen wir Zeiger i, tauschen ein [i] und ein [j] aus. Der Austausch der Elemente hilft dem Zeiger I, so dass die Elemente bis zu dem Element, das von Zeiger i ist, weniger als das Pivot -Element sind. Als letzter Schritt wechselt die Partitionsfunktion das Pivot -Element mit dem Element am Index I+1, wodurch das Pivot -Element in der richtigen Position im partitionierten Array bewegt wird.

Quellcode

Def Partition (arr, lb, ub):
# Das letzte Element des Arrays wird genommen
# Pivot -Element sein
pivot_elt = arr [ub-1]
i = lb - 1
für j in Reichweite (lb, ub):
# Wenn das Element weniger als das Pivot -Element ist
Wenn arr [j] # Tauschen Sie die Elemente so aus, dass die Elemente
# arr [lb… i] ist immer weniger als Pivot -Element
i = i + 1
arr [i], arr [j] = arr [j], arr [i]
# Final Swap des Pivot -Elements und arr [i+1]
# um das Pivot -Element einzulegen
arr [i+1], arr [ub-1] = arr [ub-1], arr [i+1]
Return i+1
Def Quick_Sort (arr, lb, ub):
if (lb# Das Array rekursiv sortieren
q = Partition (arr, lb, ub)
arr = Quick_Sort (arr, lb, q)
arr = Quick_Sort (arr, q+1, ub)
return arr
Wenn __name__ == "__main__":
arr = [3, 7, 9, 2, 5, 0]
n = len (arr)
arr = Quick_Sort (arr, 0, n)
Druck (arr)

Die Best-Case-Zeitkomplexität von Quicksort ist O (N log n). Im besten Fall unterteilt der Algorithmus in jedem Aufruf zum Algorithmus das Problem in zwei Unterprobleme gleicher Größe. Die schlimmste Zeitkomplexität des Quicksort -Algorithmus ist o (n^2). Dies tritt auf, wenn das Partitionselement immer als das letzte Element ausgewählt wird und das Array bereits sortiert ist.