Cos'è QuickSort?

QuickSort è uno degli algoritmi di smistamento efficienti. L'algoritmo esegue l'ordinamento applicando il paradigma di divisione e conquista. Considera un array A [1 ... n] di N Elements. L'algoritmo divide l'array A su un indice q in modo tale che tutti gli elementi nella sinistra sotto-array dell'indice siano minori dell'elemento nell'indice Q (a [q]) e tutti gli elementi nel sottorray destro sono maggiori [Q]. Ora, l'algoritmo ordina ricorsivamente i due subarrays A [1 ... Q-1] e un [Q+1 ... N] inplace chiamando la funzione QuickSort. Per ottenere l'indice Q, l'algoritmo utilizza una funzione di partizione.

La funzione di partizione è una funzione che prende in un array a [l ... u] come input. Qui, l è il limite inferiore, e u è il limite superiore dell'array. L'algoritmo trova un indice Q in modo tale che tutti gli elementi inferiori a un [q] cadano nel subarray a [l ... q-1], e tutti gli elementi maggiori di un [q] cadono nel subarray a [Q+1 ... u]. La funzione di partizione raggiunge questo usando un elemento per pivot e due puntatori: puntatore I e puntatore J all'array.

Il puntatore J punta al primo elemento nell'array e il puntatore I è inizializzato come J-1. La funzione itera attraverso l'array usando il puntatore j. Per l'elemento A [J], l'elemento può essere maggiore dell'elemento per pivot o inferiore all'elemento pivot. Se l'elemento è maggiore dell'elemento pivot, il puntatore J viene incrementato, indicando l'elemento successivo. Se l'elemento a [j] è inferiore all'elemento pivot, incremiamo il puntatore i, scambia un [i] e un [j]. Lo scambio degli elementi aiuta a mantenere il puntatore I in modo tale che gli elementi fino all'elemento puntato dal puntatore I sono inferiori all'elemento per pivot. Come fase finale, la funzione di partizione scambia l'elemento pivot con l'elemento all'indice I+1, spostando così l'elemento pivot nella posizione corretta nell'array partizionato.

Codice sorgente

partizione def (arr, lb, ub):
# Viene preso l'ultimo elemento dell'array
# essere elemento per pivot
pivot_elt = arr [ub-1]
i = lb - 1
per j in gamma (lb, ub):
# Se l'elemento è inferiore all'elemento per pivot
Se arr [j] # Scambia gli elementi in modo che gli elementi
# arr [lb ... i] è sempre meno dell'elemento per pivot
i = i + 1
arr [i], arr [j] = arr [j], arr [i]
# Lo scambio finale dell'elemento pivot e arr [i+1]
# per mettere in posizione l'elemento per pivot
arr [i+1], arr [ub-1] = arr [ub-1], arr [i+1]
restituire i+1
def Quick_sort (arr, lb, ub):
if (lb# Ordinando ricorsivamente l'array
Q = partizione (arr, lb, ub)
arr = Quick_Sort (arr, lb, q)
arr = Quick_Sort (arr, q+1, ub)
RITORNO ARR
Se __Name__ == "__main__":
arr = [3, 7, 9, 2, 5, 0]
n = len (arr)
arr = Quick_sort (arr, 0, n)
Stampa (ARR)

La complessità del tempo migliore di QuickSort è O (n log n). Nello scenario migliore, in ogni chiamata all'algoritmo, l'algoritmo divide il problema in due sottoproblemi di uguale dimensione. La peggiore complessità del tempo dell'algoritmo QuickSort è O (n^2). Ciò si verifica quando l'elemento di partizione viene sempre scelto come ultimo elemento e l'array è già ordinato.