Sorvi rapido Python
Esempio 1:
Iniziamo scegliendo un elemento per pivot. Quindi, per fare il giro di tutti gli elementi nell'elenco, utilizziamo Python per il loop. Se un numero è <= to the pivot, it is shifted to the left. Otherwise, it shifts to the right side of the pivot. Our Python program returns the new high value. Item + 1 equals the new high value. After that, we must execute our algorithm. A separate procedure can be created to achieve this. This function compares the values of “low_point” and “high_point” to test if “low_pont” is less than “high_point.” We'll be likely to progress if that's the case. Otherwise, our sorting will come to a halt. When our sorting comes to a halt, it signifies the list has been sorted.
Il metodo Prepare () viene quindi chiamato dal nostro codice. Questo individua un puntatore per perno e trasferisce le cose alle loro posizioni adeguate. Il metodo QuickSort () è quindi chiamato due volte dal nostro programma. Usiamo QuickSort sui pezzi a sinistra del perno per la prima volta. Per il 2 ° tentativo, usiamo QuickSort sugli oggetti a destra del perno. Di conseguenza, perché si chiama, la nostra funzione è ricorsiva. Creiamo ora un programma primario che crea un elenco ordinabile. Iniziamo specificando un insieme di valori da ordinare. La funzione Python len () viene utilizzata per determinare la lunghezza del nostro insieme di attributi. Successivamente, viene applicato il metodo QuickSort ().
Def Prepara (Data, Low_Point, High_Point):pivot = data [high_point]
n = Low_point - 1
per i in gamma (Low_point, high_point):
Se dati [i] <= pivot:
n = n + 1
(Data [n], data [i]) = (data [i], data [n])
(Data [n + 1], dati [high_point]) = (data [high_point], data [n + 1])
restituire n + 1
def Quick_sort (Data, Low_Point, High_Point):
Se low_point
Quick_sort (dati, low_point, pivot - 1)
Quick_Sort (dati, pivot + 1, high_point)
my_list = [9, 5, 1, 7, 4, 2]
totale = len (my_list)
Quick_Sort (my_list, 0, totale - 1)
Stampa (my_list)
Qui puoi vedere che i dati sono ordinati.
Esempio 2:
Useremo due funzioni in questo esempio: partizione () e QuickSort (). La funzione QuickSort () partizioni prima la raccolta, quindi si chiama ricorsivamente sui pezzi partizionati. Innanzitutto, diamo un'occhiata alla funzione Division (). Il perno è stato impostato per primo, come puoi vedere nel codice. Se il valore che stiamo visualizzando in questo momento è superiore al perno. Possiamo passare al pezzo successivo a sinistra perché è sul lato destro del perno. Dobbiamo anche assicurarci di non aver superato il puntatore basso, il che indica che tutti gli elementi sono stati spostati sul lato corretto del perno. Successivamente, viene eseguito il metodo opposto a quello sopra. Abbiamo trovato un numero fuori ordine sia per High_point che Low_Point, o Low_Point è maggiore di High_point, nel qual caso lasceremo il ciclo. Infine, mettiamo in azione il codice QuickSort (). Possiamo usare QuickSort () su un array di base per implementare entrambe le funzioni (partizione e QuickSort).
partizione def (arr1, start, end):pivot = arr1 [start]
Low_point = start + 1
high_point = end
mentre è vero:
mentre low_point = pivot:
high_point = high_point - 1
mentre low_point<= high_point and arr1[low_point] <= pivot:
Low_point = Low_point + 1
se low_point = end:
ritorno
p_func = partizione (arr1, start, end)
Quick_Sort (arr1, start, p_func-1)
Quick_Sort (arr1, p_func+1, end)
ARR1 = [23,22,56,4,26,77,10,33,44,12,57,78,22,83,43,31,98,76]
Quick_Sort (arr1, 0, len (arr1) - 1)
Stampa (ARR1)
Questo è il risultato. Non vi è alcuna garanzia che questi due 22 fossero in questo ordine perché il metodo è instabile. Forse all'inizio sono stati cambiati, ma ciò non implica nulla in un array di interi.
Esempio 3:
In questo esempio ordineremo oggetti personalizzati. Esistono diversi modi per estendere questo algoritmo per ordinare gli oggetti personalizzati in Python. Gli operatori di confronto per una classe specifica potrebbero essere implementati in uno stile pitonico, il che significa che non dovremmo cambiare l'algoritmo perché>, ==, =, ecc., funzionerebbe meglio sul nostro oggetto di classe. Un'altra opzione è che il chiamante fornisca il nostro algoritmo un metodo, che verrebbe quindi utilizzato per eseguire il confronto degli articoli effettivi. È piuttosto semplice riscrivere l'algoritmo per l'uso con oggetti su misura. Tuttavia, tieni presente che l'algoritmo non è completamente stabile. Cominciamo con la classe studentesca. Questa classe ha solo due caratteristiche: il nome e l'età dello studente. Ordineremo per età, che realizzeremo dando all'algoritmo di smistamento una nuova funzione Lambda. Ma prima, diamo un'occhiata a come questa funzione viene utilizzata nell'algoritmo. Invece di usare gli operatori = o> = per fare un confronto diretto, utilizziamo la funzione per determinare quale studente è più vecchio. Lambda trasmette l'oggetto rispetto alla chiamata di ordinamento rapido, che esegue il confronto esatto degli attributi dell'età.
Studente di classe:def __init __ (self, name_of_student, età):
se stesso.name_of_student = name_of_student
se stesso.età = età
def __str __ (self):
Restituisci se stessi.nome dello studente
DEF Partition (arr1, start, end, confront_func):
pivot = arr1 [start]
Low_point = start + 1
high_point = end
mentre è vero:
mentre low_point<= high_point and compare_func(arr1[high_point], pivot):
high_point = high_point - 1
mentre low_point<= high_point and not compare_func(arr1[low_point], pivot):
Low_point = Low_point + 1
se low_point = end:
ritorno
Qui puoi vedere l'elenco ordinato dei nomi.
Conclusione:
Un array è suddiviso utilizzando l'algoritmo Python QuickSort e quindi ordinare ogni voce nell'elenco; Questo metodo chiama ripetutamente questi secondi secondari. Abbiamo esaminato questo concetto approfondito con esempi in questo articolo.