Nota importante: Lo pseudocodice è pensato per essere una rappresentazione di alto livello, non eseguibile direttamente. Si concentra sulla * logica * dell'algoritmo. L'implementazione effettiva del codice varierà in base al linguaggio di programmazione e ai requisiti specifici.
1. Bubble ordin
* Concetto: Passa ripetutamente attraverso l'elenco, confronta elementi adiacenti e li scambia se sono nell'ordine sbagliato. Elementi più pesanti "Bubble" fino alla fine.
* pseudocodice:
`` `
Procedura Bubblesort (elenco:array di elementi)
N =lunghezza (elenco)
per i =0 a n-1 do
per j =0 a n-i-1 do
se elenco [j]> elenco [j+1] quindi
Swap List [J] ed elenco [J+1]
Termina se
fine per
fine per
procedura di fine
`` `
* Efficienza:
* Caso migliore: O (n) (quando l'elenco è già ordinato. Una versione ottimizzata può rilevare questo.)
* Caso medio: O (N
* Caso peggiore: O (N
* Complessità dello spazio: O (1) (ordinamento sul posto)
* Implementazione: Molto semplice da implementare.
* Casi d'uso: Per lo più educativo. Non è adatto per set di dati di grandi dimensioni a causa di scarse prestazioni. Può essere utile per liste piccole, quasi ordinate se ottimizzate.
2. Ordine di selezione
* Concetto: Trova l'elemento minimo nella porzione non desiderata dell'elenco e lo scambia con l'elemento all'inizio della porzione non desiderata.
* pseudocodice:
`` `
procedura selectionort (elenco:array di elementi)
N =lunghezza (elenco)
per i =0 a n-1 do
// Trova l'indice dell'elemento minimo nella parte non desiderata
min_index =i
per j =i+1 a n-1 do
se elenco [j]
Termina se
fine per
// scambia l'elemento minimo trovato con il primo elemento
swap list [i] ed elenco [min_index]
fine per
procedura di fine
`` `
* Efficienza:
* Caso migliore: O (N
* Caso medio: O (N
* Caso peggiore: O (N
* Complessità dello spazio: O (1) (ordinamento sul posto)
* Implementazione: Relativamente semplice.
* Casi d'uso: Si comporta leggermente meglio dell'ordinamento a bolle in alcuni casi, ma non è ancora adatto per set di dati di grandi dimensioni. Il numero di swap è limitato a O (n), che può essere utile se le scritture di memoria sono costose.
3. Ordine di inserzione
* Concetto: Costruisce l'elenco ordinato un elemento alla volta. Itera attraverso i dati di input, rimuove un elemento alla volta, trova la posizione corretta per esso nell'elenco ordinato e lo inserisce lì.
* pseudocodice:
`` `
Procedura InsertionSort (elenco:array di articoli)
N =lunghezza (elenco)
per i =1 a n-1 do
Key =elenco [i]
j =i - 1
// Sposta gli elementi dell'elenco [0..I-1], che sono più grandi della chiave,
// in una posizione prima della loro posizione attuale
mentre j> =0 ed elenco [j]> tasto do
Elenco [j+1] =elenco [j]
j =j - 1
terminare mentre
Elenco [J+1] =Key
fine per
procedura di fine
`` `
* Efficienza:
* Caso migliore: O (n) (quando l'elenco è già ordinato)
* Caso medio: O (N
* Caso peggiore: O (N
* Complessità dello spazio: O (1) (ordinamento sul posto)
* Implementazione: Semplice ed efficiente per piccoli set di dati o dati quasi ordinati.
* Casi d'uso: Buono per piccoli elenchi o quando ti aspetti che i dati di input vengano per lo più ordinati. Inoltre, è un algoritmo * online * che significa che può ordinare un elenco quando lo riceve.
4. Unisci ordinamento
* Concetto: Un algoritmo di divisione e conquista. Divide l'elenco in sublisti più piccoli, ordina ricorsivamente i sublisti e poi li unisce.
* pseudocodice:
`` `
Procedura Mergesort (elenco:array di elementi)
N =lunghezza (elenco)
Se n <=1 allora
Elenco di resi // già ordinato
Termina se
// Dividi l'elenco in due metà
Mid =N / 2
LeftList =List [0 a Mid-1]
RightList =elenco [medio a n-1]
// ordina ricorsivamente ogni metà
LeftList =Mergesort (LeftList)
RightList =Mergesort (Rightlist)
// unisci le metà ordinate
Return Munge (sinistra, destra)
procedura di fine
procedura unione (Elist a sinistra:array di articoli, lista di destra:array di elementi)
ResultList =nuovo array
Mentre la lista di sinistra non è vuota e la lista di destra non è vuota
Se sinistra [0] <=destra [0] allora
Aggiungi sinistro [0] a ResultList
Rimuovi a sinistra [0] da sinistra
altro
Append Rightlist [0] a ResultList
Rimuovi la destra [0] da destra
Termina se
terminare mentre
// Aggiungi eventuali elementi rimanenti da sinistra o destra
Aggiungi tutti gli elementi rimanenti di sinistra alla lista dei risultati
Aggiungi tutti gli elementi rimanenti della lista di destra alla lista dei risultati
Restituisce il risultato
procedura di fine
`` `
* Efficienza:
* Caso migliore: O (n log n)
* Caso medio: O (n log n)
* Caso peggiore: O (n log n)
* Complessità dello spazio: O (n) (richiede spazio extra per la fusione)
* Implementazione: Più complesso rispetto agli algoritmi precedenti, ma fornisce buone prestazioni per set di dati di grandi dimensioni.
* Casi d'uso: Adatto per ordinare elenchi di grandi dimensioni in cui sono importanti prestazioni coerenti.
5. Ordine rapida
* Concetto: Anche un algoritmo di divisione e conquista. Scegli un elemento come perno e suddivide l'array dato attorno al perno raccolto.
* pseudocodice:
`` `
Procedura QuickSort (elenco:array di articoli, basso:int, alto:int)
Se basso
P =partizione (elenco, basso, alto)
// Ordina separatamente gli elementi prima della partizione e dopo la partizione
QuickSort (elenco, basso, P-1)
QuickSort (elenco, p+1, alto)
Termina se
procedura di fine
partizione procedura (elenco:array di articoli, basso:int, alto:int)
Pivot =elenco [alto] // Scegli l'ultimo elemento come perno
i =basso - 1 // indice di elemento più piccolo
per j =da basso a alto 1
// Se l'elemento corrente è inferiore o uguale al perno
Se elenco [j] <=pivot allora
i =i + 1 // INDICE INCREMPO ELEMENTO PIÙ PIÙ
swap list [i] ed elenco [j]
Termina se
fine per
Elenco di swap [i + 1] ed elenco [alto]
restituire i + 1
procedura di fine
`` `
* Efficienza:
* Caso migliore: O (n log n) (quando il perno è sempre la mediana)
* Caso medio: O (n log n)
* Caso peggiore: O (N
* Complessità dello spazio: O (log n) (a causa di chiamate ricorsive, può essere O (n) nel peggiore dei casi)
* Implementazione: Generalmente veloce nella pratica, ma le sue prestazioni peggiore possono essere una preoccupazione. La scelta del perno influisce in modo significativo sulle sue prestazioni.
* Casi d'uso: Spesso l'algoritmo di smistamento più veloce in pratica per set di dati di grandi dimensioni. Tuttavia, le sue prestazioni nel caso peggiore devono essere prese in considerazione. Molte implementazioni utilizzano randomizzazione o altre tecniche per evitare il peggiore dei casi.
6. Heap ordin
* Concetto: Costruisce un heap massimo (o un heap min) dai dati di input e quindi estrae ripetutamente l'elemento radice (l'elemento più grande o più piccolo) e lo posiziona alla fine dell'array ordinato.
* pseudocodice:
`` `
PROCEDURA HAPSORT (elenco:array di elementi)
N =lunghezza (elenco)
// Build Max heap
per i =n/2 - 1 down a 0 do
heapify (elenco, n, i)
fine per
// uno per uno estrarre un elemento da heap
per i =n-1 fino a 0 do
Swap List [0] ed elenco [i] // Sposta la radice corrente su End
// Chiama il mucchio massimo sul mucchio ridotto
heapify (elenco, i, 0)
fine per
procedura di fine
Procedura HeaPify (elenco:array di elementi, n:int, i:int)
più grande =i // inizializza il più grande come root
a sinistra =2*i + 1
a destra =2*i + 2
// Se il bambino a sinistra è più grande della radice
Se lasciato
più grande =sinistra
Termina se
// Se il bambino giusto è più grande del più grande finora
Se giusto
più grande =diritto
Termina se
// Se il più grande non è root
se più grande! =io allora
swap list [i] ed elenco [più grande]
// accumulare ricorsivamente il sotto-tree interessato
heaPify (elenco, n, più grande)
Termina se
procedura di fine
`` `
* Efficienza:
* Caso migliore: O (n log n)
* Caso medio: O (n log n)
* Caso peggiore: O (n log n)
* Complessità dello spazio: O (1) (ordinamento sul posto)
* Implementazione: Più complessi degli algoritmi più semplici, ma garantisce prestazioni O (n log n).
* Casi d'uso: Una buona scelta quando è necessario garantire prestazioni O (n log n) e ordinamento sul posto. Utilizzato nelle implementazioni di code prioritarie.
Sommario Tabella delle efficienze
| Algoritmo | Miglior caso | Caso medio | Caso peggiore | Complessità spaziale |
| ------------------- | ----------- | -------------- | ------------ | ------------------- |
| Bolle Sort | O (n) | O (N
| Ordinamento di selezione | O (N
| Ordinamento di inserzione | O (n) | O (N
| Unisci ordinamento | O (n log n) | O (n log n) | O (n log n) | O (n) |
| Ordine rapida | O (n log n) | O (n log n) | O (N
| Ordine heap | O (n log n) | O (n log n) | O (n log n) | O (1) |
Differenze chiave nell'efficienza e nell'implementazione:
* Quadratico vs. logaritmico: Algoritmi con O (n
* Dividi e conquista: Unisci l'ordinamento e l'ordinamento rapido utilizza la strategia di divisione e conquista, che consente un smistamento più efficiente di set di dati di grandi dimensioni.
* Ordinamento nel posto: L'ordinamento delle bolle, l'ordinamento di selezione, l'ordinamento di inserimento e l'ordinamento heap sono algoritmi di smistamento sul posto, il che significa che non richiedono una memoria extra significativa. L'ordinamento di unione richiede O (n) spazio extra per la fusione. L'ordinamento rapido richiede in media O (log n) ma O (n) sul caso peggiore a causa delle chiamate ricorsive.
* Stabilità: Un algoritmo di ordinamento è * stabile * se gli elementi con valori uguali mantengono il loro ordine relativo dopo l'ordinamento. L'ordinamento e l'ordinamento di inserimento sono stabili, mentre l'ordinamento di heap e la sorta rapida (nella loro forma di base) non lo sono. La stabilità può essere importante in alcune applicazioni.
* PIVOT Choice (Ordine rapida): Le prestazioni di Sort Sort dipendono fortemente dalla scelta dell'elemento perno. Le cattive scelte di perno possono portare al peggiore dei casi O (N
* Complessità dell'implementazione: L'ordinamento delle bolle e l'inserimento sono i più semplici da implementare. Unisci ordinamento, ordinamento rapido e heap sono più complessi.
* Adattività: L'ordinamento di inserimento è adattivo, il che significa che le sue prestazioni migliorano se i dati di input sono già parzialmente ordinati.
Scegliere l'algoritmo giusto:
Il miglior algoritmo di ordinamento da utilizzare dipende dall'applicazione specifica e dalle caratteristiche dei dati. Considera questi fattori:
* Dimensione del set di dati: Per set di dati molto piccoli, la semplicità dell'ordinamento delle bolle o dell'ordinamento di inserimento può essere sufficiente. Per set di dati più grandi, l'ordinamento di unione, l'ordinamento rapido o l'ordinamento di heap sono generalmente scelte migliori.
* Livello di ordinamento: Se i dati sono già per lo più ordinati, l'inserimento potrebbe essere l'opzione più veloce.
* Vincoli di memoria: Se la memoria è limitata, sono preferiti algoritmi di smistamento sul posto come Ordine di bolle, Ordine di selezione, Ordine di inserimento e Ordine del Heap.
* Requisiti di stabilità: Se è necessaria la stabilità, scegli un algoritmo di smistamento stabile come l'ordinamento di unione o l'ordinamento di inserimento.
* Prestazioni peggiori: Se hai bisogno di prestazioni garantite, evita un ordinamento rapido (a meno che non sia implementato con randomizzazione per pivot o altre strategie per mitigare il comportamento peggiore).
* Facilità di implementazione e manutenzione: Considera il compromesso tra prestazioni e complessità dell'attuazione.
Spero che questa spiegazione dettagliata aiuti! Fammi sapere se hai ulteriori domande.
Informazioni correlate
software © www.354353.com