ordinamento è tradizionalmente un compito difficile in informatica . La scelta di un algoritmo di ordinamento che sia efficiente e veloce può essere difficile . Spesso , la scelta efficiente algoritmo implica la conoscenza dei dati che vengono ordinati , e ordina specializzati di solito lavorano molto meglio di algoritmi di ordinamento generalizzate . Tuttavia, alcune specie , come ad esempio il " merge sort , " in grado di lavorare in situazioni generalizzate , abbattendo set e smistamento pezzi più piccoli in modo ricorsivo . La Lista

Un merge sort è un "divide et impera " algoritmo , in quanto tiene porzioni delle liste e li rompe continuamente a metà fino a raggiungere i singoli elementi della lista , che sono poi confluite in ordine . Per esempio , iniziare con un elenco numerico come

5 6 2 4 1 9 8 3 7

Ordinamento di un elenco come questo , con una sorta di unione richiede dimezzare le dimensioni dell'elenco fino a quando ogni numero di base esiste solo. Poi , il genere può confrontare i numeri e metterli insieme in modo corretto ( più basso al più alto, in questo caso) .
Il Merge Metodo

Il metodo di fusione è semplice :

def unione ( primo, secondo ) per

Facendo due liste , il metodo si fondono insieme avviando all'inizio di ogni lista. E poi aggiunge la prossima minor quantità di ciascuna lista in un nuovo elenco . Il risultato è un elenco ordinato . ( Ricordati di inserire correttamente lo spazio bianco scheda dopo il " mentre" e le dichiarazioni " if /else " . ) :

Mentre i < len ( prima) e j < len ( secondo) :
< p > Se prima [ i] < = seconda [ j ] :

new_list.append ( prima [ i] ) per

i = i + ​​1

altro :

new_list.append ( secondo [ j ] ) per

j = j + 1}

Finalmente, dopo si finisce lista , i restanti valori sono posti nel nuovo elenco :

new_list + = primi [i: ]

new_list + = secondo [ j: ]

ritorno end_list
merge sort Condizioni

il merge sort attuale spinge l' algoritmo di ordinamento principale. Ci sono due parti funzionali principali : l'aspetto condizionale che interrompe la ricorsione una volta che le liste sono suddivise e la ricorsione effettivo che dimezza le liste . La condizione di arresto viene prima :

def mergesort (elenco ) :

if len (lista ) == 1 :

ritorno elenco

Ciò assicura che quando un elenco sub raggiunge solo un elemento , tale elemento viene restituito in modo che venga fusa con gli altri numeri .
Merge Sort ricorsione

La seconda metà del il genere è la ricorsione . Dopo la "if" /condizionale , come segue :

altro :

middle = len (lista ) /2

start = mergesort (elenco [ mezzo : ] )

end = mergesort ( lista [ : centrale ] ) per

ritorno unione ( inizio, fine ) per

causa della ricorsione , dopo che gli elenchi sono suddivisi in singoli elementi , l'algoritmo i brani fino all'ultimo metodo eseguito . Quindi , per il momento l' istruzione "return unione ( inizio, fine ) " esegue , l'algoritmo restituisce una fusione , elenco ordinato dei due precedentemente unite , liste ordinate di dimensioni più piccole .