FireTeam » sort http://www.fireteam.it #fuoco@AzzurraNet Tue, 16 Mar 2010 15:55:56 +0000 http://wordpress.org/?v=2.8.4 en hourly 1 Implementazione C di Heap Sort http://www.fireteam.it/2009/07/implementazione-c-di-heap-sort/ http://www.fireteam.it/2009/07/implementazione-c-di-heap-sort/#comments Fri, 10 Jul 2009 21:20:14 +0000 saverio http://www.fireteam.it/?p=475 L’ heapsort è un algoritmo di ordinamento iterativo ed in-place proposto da Williams nel 1964, che si basa su strutture dati ausiliarie.

L’ heapsort per eseguire l’ordinamento, utilizza una struttura chiamata heap (mucchio); un heap è rappresentabile con un albero binario in cui tutti i nodi seguono una data proprietà, detta priorità. Esso è completo almeno fino al penultimo livello dell’albero e ad ogni nodo corrisponde uno ed un solo elemento.

In uno heap decrescente (utilizzato per ordinare ad esempio un array in senso crescente) ogni nodo padre contiene un valore maggiore o uguale a quello dei suoi due figli diretti, di conseguenza risulterà maggiore anche di tutti i nodi che si trovano nel sottoalbero di cui esso è la radice; questo non implica affatto che nodi a profondità maggiore contengano valori minori di quelli a profondità minore.

Quindi in ogni istante, in un heap decrescente, la radice contiene il valore maggiore.

Questa struttura è molto usata, in particolare, per l’ordinamento di array.

In questo caso si considera come radice l’elemento iniziale di indice 1; inoltre i figli di un nodo con indice j, avranno indice rispettivamente 2j, quello sinistro, 2j+1 quello destro.

Per comprendere meglio il funzionamento dell’algoritmo è bene capire che gli elementi che si trovano nella seconda metà dell’array rappresenteranno foglie dello heap e quindi esse saranno già al loro posto giusto; non vi è infatti alcun elemento dopo di esse.

…tratto da wikipedia

Implementazione Iterativa di Heap Sort

L’algoritmo che ordina in senso crescente inizia creando uno heap decrescente. Per ogni iterazione si copia la radice (primo elemento dell’array) in fondo all’array stesso, eseguendo uno scambio di elementi. L’algoritmo poi ricostruisce uno heap di n – 1 elementi spostando verso il basso la nuova radice, e ricomincia con un altro scambio (tra il primo elemento dell’array e quello in posizione n – 1), eseguendo un ciclo che considera array di dimensione progressivamente decrescente.

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

#include <stdio.h>
#define MAX 20
 
int sinistro(int i)
{
 return 2*i+1;
}
 
int destro(int i)
{
 return 2*i+2;
}
 
int padre(int i)
{
 return (int)(i-1/2);
}
 
stampavettore(int *vettore,int n)
{
 int i;
 
 for(i=0 ; i<=n ; printf("%d ",vettore[i++]));
}
 
int riempivettore(int *vettore)
{
 int i;
 
 i=0;
 do {
 printf("inserire l'elemento %d dell'array('-1' per terminare): ",i+1);
 scanf("%d",vettore+i);
 } while (vettore[i++] != -1);
 return i-2;
}
 
void scambia(int *n1,int *n2)
{
 int temp;
 
 temp = *n1;
 *n1 = *n2;
 *n2 = temp;
}
 
void heapify(int *vettore, int i,int heapsize)
{
 int l,r,maggiore,violazione=1;
 
 while (violazione)
 {
 l = sinistro(i);
 r = destro(i);
 
 if ((l <= heapsize) && (vettore[l] > vettore[i]))
 {
 maggiore = l;
 }
 else 
 {
 maggiore = i;
 }
 
 if ((r <= heapsize) && (vettore[r]>vettore[maggiore]))
 {
 maggiore = r;
 }
 if (maggiore != i)
 {
 scambia(&vettore[i],&vettore[maggiore]);
 i=maggiore;
 }
 else
 {
 violazione = 0;
 }
 }
}
 
void buildheap(int *vettore,int heapsize,int n)
{
 int i;
 
 for (i=(int)(n/2) ; i>=0 ; i--)
 {
 heapify(vettore,i,heapsize);
 }
}
 
heapsort(int *vettore,int n)
{
 int i,heapsize;
 
 heapsize=n;
 buildheap(vettore,heapsize,n);
 for (i=n ; i>0 ; i--)
 {
 scambia(&vettore[0],&vettore[i]);
 heapsize--;
 heapify(vettore,0,heapsize);
 }
}
 
main()
{
 int vettore[MAX];
 int n; /*numero di elementi*/
 
 n=riempivettore(vettore);
 
 heapsort(vettore,n);
 
 stampavettore(vettore,n);
}

Si può dimostrare che la complessità asintotica massima dell’heap sort è O(nlogn). Tuttavia, in generale (e soprattutto per array quasi ordinati) altri algoritmi con la medesima complessità asintotica, per esempio quick sort o merge sort, ottengono migliori prestazioni. Per array di piccole dimensioni è addirittura più veloce l’insertion sort nonostante abbia una complessità di O(n^2))

Implementazione Ricorsiva di Heap Sort

Qui vi è l’implementazione ricorsiva in linguaggio C di Heap Sort

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

#include <stdio.h>
#define MAX 20
 
int sinistro(int i)
{
 return 2*i+1;
}
 
int destro(int i)
{
 return 2*i+2;
}
 
int padre(int i)
{
 return (int)(i-1/2);
}
 
stampavettore(int *vettore,int n)
{
 int i;
 
 for(i=0 ; i<=n ; printf("%d ",vettore[i++]));
}
 
int riempivettore(int *vettore)
{
 int i;
 
 i=0;
 do {
 printf("inserire l'elemento %d dell'array('-1' per terminare): ",i+1);
 scanf("%d",vettore+i);
 } while (vettore[i++] != -1);
 return i-2;
}
 
void scambia(int *n1,int *n2)
{
 int temp;
 
 temp = *n1;
 *n1 = *n2;
 *n2 = temp;
}
 
void heapify(int *vettore, int i,int heapsize)
{
 int l,r,maggiore;
 
 l = sinistro(i);
 r = destro(i);
 
 if ((l <= heapsize) && (vettore[l] > vettore[i]))
 {
 maggiore = l;
 }
 else
 {
 maggiore = i;
 }
 
 if ((r <= heapsize) && (vettore[r]>vettore[maggiore]))
 {
 maggiore = r;
 }
 if (maggiore != i)
 {
 scambia(&vettore[i],&vettore[maggiore]);
 heapify(vettore,maggiore,heapsize);
 }
}
 
void buildheap(int *vettore,int heapsize,int n)
{
 int i;
 
 for (i=(int)(n/2) ; i>=0 ; i--)
 {
 heapify(vettore,i,heapsize);
 }
}
 
heapsort(int *vettore,int n)
{
 int i,heapsize;
 
 heapsize=n;
 buildheap(vettore,heapsize,n);
 for (i=n ; i>0 ; i--)
 {
 scambia(&vettore[0],&vettore[i]);
 heapsize--;
 heapify(vettore,0,heapsize);
 }
}
 
main()
{
 int vettore[MAX];
 int n; /*numero di elementi*/
 
 n=riempivettore(vettore);
 
 heapsort(vettore,n);
 
 stampavettore(vettore,n);
}
]]> http://www.fireteam.it/2009/07/implementazione-c-di-heap-sort/feed/ 0 Implementazione C del Quicksort http://www.fireteam.it/2009/07/implementazione-c-del-quicksort/ http://www.fireteam.it/2009/07/implementazione-c-del-quicksort/#comments Tue, 07 Jul 2009 20:55:13 +0000 saverio http://www.fireteam.it/?p=428 FunzionamentoQuicksortQuicksort è un ottimo algoritmo di ordinamento ricorsivo in place che, come merge sort, si basa sul paradigma divide et impera. La base del suo funzionamento è l’utilizzo ricorsivo della procedura partition: preso un elemento da una struttura dati (es. array) si pongono gli elementi minori a sinistra rispetto a questo e gli elementi maggiori a destra.

Il Quicksort, termine che tradotto letteralmente in italiano indica ordinamento rapido, è l’algoritmo di ordinamento che ha, in generale, prestazioni migliori tra quelli basati su confronto; è stato sottoposto a un’analisi matematica approfondita ed estremamente precisa, tanto che le sue prestazioni sono state comprese a fondo e il suo comportamento è stato descritto in modo molto accurato.

I risultati ottenuti in fase di analisi sono stati verificati sperimentalmente in modo esteso e l’algoritmo di base è stato migliorato al punto da diventare il metodo ideale per un gran numero di applicazioni pratiche.

tratto da wikipedia

Per la sua estrema facilità è stato scelto in molte librerie di linguaggi, come il C, di implementare di base una funzione che effettui l’ordinamento del Quicksort… però il nostro professore di programmazione vuole vedere il codice sorgente :-)

Codice C Quicksort

Eccolo qua:

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

#include <stdio.h>
#define MAX 20
 
stampavettore(int *vettore,int n)
{
 int i;
 
 for(i=0 ; i<=n ; printf("%d ",vettore[i++]));
}
 
int riempivettore(int *vettore)
{
 int i;
 
 i=0;
 do {
 printf("inserire l'elemento %d dell'array('-1' per terminare): ",i+1);
 scanf("%d",vettore+i);
 } while (vettore[i++] != -1);
 return i-2;
}
 
void scambia(int *n1,int *n2)
{
 int temp;
 
 temp = *n1;
 *n1 = *n2;
 *n2 = temp;
}
 
int partiziona(int *vettore, int p, int r)
{
 int x = vettore[p];
 int i = p-1;
 int j = r+1;
 int itera = 1;
 
 do {
 for(; vettore[--j] > x ;);
 for(; vettore[++i] < x ;);
 
 if (i < j)
 {
 scambia(&vettore[i],&vettore[j]);
 }
 else
 {
 itera = 0;
 }
 } while (itera);
 
return j;
}
 
void quicksort(int *vettore, int p, int r)
{
 int q;
 
 if (p < r)
 {
 q = partiziona(vettore,p,r);
 quicksort(vettore,p,q);
 quicksort(vettore,q+1,r);
 }
}
 
main()
{
 int vettore[MAX];
 int n; /*numero di elementi*/
 
 n=riempivettore(vettore);
 
 quicksort(vettore,0,n);
 
 stampavettore(vettore,n);
}

Caratteristiche del Quicksort

Struttura dati Variabile
Caso pessimo temporalmente Θ(n2)
Caso ottimo temporalmente Θ(nlogn)
Caso medio temporalmente Θ(nlogn) confronti
Caso pessimo spazialmente Dipende dalle implementazioni
Ottimale Spesso
]]> http://www.fireteam.it/2009/07/implementazione-c-del-quicksort/feed/ 2