Comb sort: differenze tra le versioni

Contenuto cancellato Contenuto aggiunto
Ansolid (discussione | contributi)
Nessun oggetto della modifica
Rimuovo F dimenticato
 
(38 versioni intermedie di 25 utenti non mostrate)
Riga 1:
{{Infobox Algoritmo
|classclasse = [[Algoritmo di ordinamento]]
|immagine = Comb sort demo.gif
|image=
|datastruttura dati = [[Array]]
|timetempo = <math>O(n log n)</math>
|spacespazio = <math>O(n)</math>
|optimalottimale = ?
|completo =
}}
In [[Informatica]], il '''combComb sort''' è un algoritmo di ordinamento ideatopubblicato per la prima volta da [[Stephen Lacey]] e [[Richard Box]], nell'sul numero di aprile [[1991]] della rivista [[Byte (rivista)|Byte]].<ref name=":0">{{Cita web|url=https://kanasz.blogspot.com/2010/12/comb-sort.html|titolo=Programming blog: Comb Sort|autore=Robert Kanasz|sito=Programming blog|data=2010-12-02|accesso=2024-06-29}}</ref> Il Comb sort rielabora le idee che Wlodzimierz Dobosiewicz applicò nel [[1980]] per rendere più efficiente lo [[shell sort]] utilizzando la funzione del [[bubble sort]].<ref name=":0" /> Il Comb sort migliora l'algoritmo [[bubble sort]] e compete in velocità con algoritmi storicamente veloci come il [[QuicksortMerge sort]]. L'idea basilare dell'algoritmo è quella di eliminare le cosiddette "''[[Bubble sort#Conigli e tartarughe|tartarughe]]''", ovvero valori piccoli vicinovicini laalla fine della lista, essendo provato che in un bubble sort questi valori tendono spessissimo a scendere nella loro posizione in modo tremendamente lento. (i "''[[Bubble sort#Conigli e tartarughe|conigli]]''", ovvero grandi valori all'inizio della lista, non rappresentano un problema nel bubble sort perché generalmente vengono spostati molto velocemente).
 
Nel bubble sort, quando vengono confrontati due elementi, essi hanno sempre un ''gappasso'' (distanza reciproca) pari ad 1.<ref>{{Cita web|url=https://xlinux.nist.gov/dads/HTML/combSort.html|titolo=comb sort|sito=xlinux.nist.gov|accesso=2024-06-29}}</ref><ref name=":0" /> L'idea alla base del comb sort è che il gappasso puòpossa essere anche maggiore<ref>{{Cita web|url=https://www.dmi.unict.it/messina/didat/prog1_23_24/21_ordinamento.pdf|titolo=Algoritmi (Anchedi loordinamento: [[ShellBubble sort]] è basato su questa idea, ma esso rappresenta una modifica dell'[[insertion sort]] piuttosto che del bubble sort).
Selection sort, Insertion sort|autore=Fabrizio Messina|pp=4-8}}</ref> (anche lo [[Shell sort]] è basato su questa idea, ma esso rappresenta una modifica dell'[[insertion sort]] piuttosto che del bubble sort<ref>{{Cita web|url=https://www.geeksforgeeks.org/shellsort/|titolo=ShellSort|sito=GeeksforGeeks|data=2014-06-16|lingua=en-US|accesso=2024-06-29}}</ref>).
 
LIl ''passo'', o intervallo didel confronto, cominciaè comeimpostato lainizialmente alla lunghezza dell'[[array]] da ordinare, divisa per il ''fattore shrinkdi riduzione'' (generalmente 1,3), e la lista viene ordinata con tale intervallo (arrotondato per difetto all'intero, se necessario). AlchèTerminato essoil primo passaggio il passo viene diviso nuovamente per il fattore Shrinkdi riduzione (arrotondato all'intero), e la lista viene ordinata con questo nuovo intervallo. Il processo si ripete finché il gappasso è pari a 1. A questo punto, combil Comb sort continua ad usare un gappasso di 1 finché non si ha un ordinamento totale. Il passaggio finale dell'algoritmo è quindi equivalente ad un bubble sort, ma in questo modo molte "tartarughe" sono scomparse, ed in tal modo il bubble sort è molto più efficiente.
 
== Fattore Shrinkdi riduzione==
Il fattore Shrinkdi riduzione ha un grande peso sull'efficienza del combComb sort. Ai tempi della sua creazione, gli autori suggerirono di usare il valore di 1.,3 in base a delle prove sperimentali basate sulla casualità. Un valore troppo piccolo degrada lle prestazioni dell'algoritmo perché si necessitarendono dinecessari più confronti, mentre uncon valore troppo alto non si riuscirebbe ad eliminare un numero sufficiente di "tartarughe" pertale essereda rendere il comb sort un miglioramento sostanziale del bubble sort.
 
Il valore consigliato come fattore è <math>1/(1-\frac{1}{e^\varphi}) \approx 1.247330950103979</math>.
 
== Combsort11 Varianti==
=== Combsort11 ===
Con un fattore di 1,3, ci sono solo tre possibili modi di concludere una lista di intervallipassi: (9, 6, 4, 3, 2, 1), (10, 7, 5, 3, 2, 1), oppure (11, 8, 6, 4, 3, 2, 1). Soltanto l'ultima sequenza uccideelimina tutte le "tartarughe" prima che il gappasso divenga 1. Ragion per cui, si hanno miglioramenti significativi in velocità se l'intervallo viene settatoimpostato ad 11 ogni qual voltaqualvolta esso debba diventare 9 o 10. Questa variazione è chiamata Combsort11.
 
Questo si nota anche perché se si arrivasse ad usare un intervallo pari a 9 o a 10, il passo finale con un intervallo pari ad 1 sarebbe più inefficiente in quanto ripetuto due volte. I dati sono ordinati quando non si effettuano scambi tra valori durante tutta la scansione dell'array con intervallo 1.
 
Un'altra ottimizzazione è quella di utilizzare una tabella da cui scegliere il passo da usare ad ogni scorrimento dei dati.
 
=== Combsort con altri metodi conclusivi ===
Come molti altri algoritmi (tipo il quick sort o il [[merge sort]]), il Comb sort è più efficiente durante i passaggi iniziali che in quelli finali, quando tende ad assomigliare al bubble sort. Il Comb sort può perciò essere reso più efficiente se il metodo di ordinamento viene cambiato non appena i passi raggiungono dei valori sufficientemente piccoli. Ad esempio, non appena il passo raggiunge o passa sotto il valore di 10, si può terminare l'utilizzo del comb sort e finire l'ordinamento utilizzando uno [[gnome sort]] o uno [[shaker sort]] o, meglio ancora, un [[insertion sort]], incrementando l'efficienza complessiva dell'ordinamento.
 
Un altro vantaggio di questo metodo è dato dal non dover tenere traccia degli scambi durante i vari passaggi per verificare se l'ordinamento si deve fermare oppure no.
 
== Pseudocodice ==
Implementazione del Comb sort classico:
 
'''function''' combsort('''array''' input)
gap:= input.size <span style="color:green">//inizializza la dimensione del passo</span>
 
'''loop until''' gap <= 1 '''and''' swaps = 0
<span style="color:green">//aggiorna il valore del passo per il prossimo passaggio</span>
gap:= int(gap / 1.25)
<br />
i:= 0
swaps:= 0 <span style="color:green">//vedi [[bubble sort]] per una spiegazione</span>
<br />
<span style="color:green">//un singolo "comb" sulla lista dei dati</span>
'''loop until''' i + gap >= input.size<span style="color:green"> //vedi [[shell sort]] per un'idea simile</span>
'''if''' input[i] > input[i+gap]
[[Swap (computer science)|swap]](input[i], input[i+gap])
swaps:= 1 <span style="color:green">// È stato eseguito uno scambio, perciò</span>
<span style="color:green">// la lista potrebbe non essere ordinata</span>
'''end if'''
i:= i + 1
'''end loop'''
<br />
'''end loop'''
'''end function'''
 
Implementazione del Combsort11:
'''function''' combsort11('''array''' input)
gap := input.size <span style="color:green">//initializeinizializza gapla sizedimensione del passo</span>
 
'''loop until''' gap = 1 '''and''' swaps = 0
<span style="color:green">//updateaggiorna theil gapvalore valuedel forpasso aper nextil combprossimo passaggio</span>
'''if''' gap > 1
gap := gap / 1.3
'''if''' gap = 10 '''or''' gap = 9
gap := 11
'''end if'''
'''end if'''
<br />
i := 0
swaps := 0 <span style="color:green">//seevedi [[bubblesortbubble sort]] forper anuna explanationspiegazione</span>
<span style="color:green">//aun singlesingolo "comb" oversulla thelista inputdei listdati</span>
'''loop until''' i + gap >= array.size
'''if''' array[i] > array[i+gap]
[[Swap (computer science)|swap]](array[i], array[i+gap])
swaps := swaps + 1
'''end if'''
i := i + 1
'''end loop'''
'''end loop'''
'''end function'''
 
 
==Note==
<references/>
 
== Voci correlate ==
* [[algoritmo di ordinamento]]
* [[Bubble sort]], L'algoritmo base del comb sort
* [[Cocktail sort]], o bubble sort bidirezionale, è una variazione che riesce a disperdere velocemente le tartarughe.
 
== Altri progetti ==
{{interprogetto}}
 
== Collegamenti esterni ==
*[{{cita web|url=http://www.sharpdeveloper.net/content/archive/2007/08/14/dot-net-data-structures-and-algorithms.aspx |titolo=Implementazione .NET del comb sort]|accesso=20 settembre 2007|urlarchivio=https://web.archive.org/web/20120212173240/http://www.sharpdeveloper.net/content/archive/2007/08/14/dot-net-data-structures-and-algorithms.aspx|urlmorto=sì}}
 
{{Ordinamento}}
{{portale|informatica}}
[[Categoria:Algoritmi di ordinamento]]
 
[[Categoria:Algoritmi di ordinamento]]
[[de:Combsort]]
[[en:Comb sort]]
[[es:Comb sort]]
[[hu:Fésűs rendezés]]
[[ja:コムソート]]
[[pl:Sortowanie grzebieniowe]]
[[tr:Tarak sıralaması]]
[[uk:Сортування гребінцем]]