3.3 Ordenação por Heap (Heapsort)

Transcrição

1 3.3 Ordenação por Heap (Heapsort) Heap descendente (max heap ou arvore descendente parcalmente ordenada) de tamanho n é um array que pode ser vsto como uma arvore bnára quase completa de n nós tal que a chave de cada nó seja menor ou gual à chave de seu pa. ada nó da arvore corresponde um elemento do array. A raz da arvore é A[]. Dado um elemento no array a posção de seu pa, flho da esquerda e flho da dreta podem ser calculados da segunte forma: nt parent (nt ) nt left (nt ) nt rght (nt ) return (floor(/2)); return (2*); return (2*+);

2 Uma mportante propredade que caracterza um Heap é que para todo nó dferente da raz A[parent()] >= A[] Outra propredade mportante de um Heap é que todo camnhamento em profunddade na arvore gera uma seqüênca ordenada de elementos O algortmo de ordenação HEAPSORT utlza três funções: - HEAPIFY - BUILDHEAP - HEAPSORT 2

3 HEAPIFY A função HEAPIFY tem como entrada um array e um índce. Quando HEAPIFY é chamada ela assume que as sub-árvores left() e rght() já satsfazem a propredade de Heap, mas A[] pode ser menor que seus flhos. A função de HEAPIFY é tornar a árvore com raz em um Heap. /* Suponha heapsze uma varavel global e A um array comecando em 0*/ vod HEAPIFY(nt A[ ], nt heapsze, nt ) nt l, r, largest; l = left(); r = rght(); f ((l <= heapsze) && (A[l] > A[])) largest = l; else largest = ; f ((r <= heapsze) && (A[r] > A[largest])) largest = r; f (largest!= ) swap(a[], A[largest]); /* troca a poscao dos elementos */ HEAPIFY(A, heapsze, largest); return; 3

4 Exemplo de HEAPFY BUILDHEAP A função BUILDHEAP é gerar a partr de um array qualquer um Heap utlzando o HEAPIFY. vod BUILDHEAP (nt *A, nt heapsze) nt ; for ( = floor(heapsze/2); > 0; --) HEAPIFY(A, heapsze, ); Obs.: os elementos em subvetor A[floor((heapsze/2)+).. heapsze] são folhas da arvore, cada um é um heap de um elemento. Portanto, só precsa aplcar HEAPFY para elementos restantes (não folhas). 4

5 Exemplo: A

6 vod HEAPSORT(nt *A, nt heapsze) nt ; BUILDHEAP(nt *A, nt heapsze) for ( = heapsze; > ; --) swap(a[], A[]); heapsze--; HEAPIFY(A, heapsze, ); Exemplo:

7

8 Efcênca de HEAPSORT T HEAPIFY (n) = O(h), onde h é a altura da sub-arvore Observe que tempo da HEAPIFY vara com a profunddade do nó na arvore. Observe também que um heap de n elementos tem no máxmo n/2 h+ nós de altura h. O tempo requerdo pela HEAPIFY quando chamada sobre um nó de altura h é O(h). Então, o tempo total da BUILDHEAP é logn h= 0 logn n h h O( h) = O n O n = O n h h = + h 2 h= 0 2 h= 0 2 T HEAPSORT (n) = O(nlogn) ( ) 8

9 4 ORDENAÇÃO POR INTERALAÇÃO (MergeSort) A déa prncpal deste algortmo é combnar duas lstas já ordenadas. O algortmo quebra um array orgnal em dos outros de tamanhos menores recursvamente até obter arrays de tamanho, depos retorna da recursão combnando os resultados. Algortmo vod MergeSort(nt *A, nt e, nt d) nt q; f (e < d) q = floor((e+d)/2); MergeSort(A, e, q); MergeSort(A, q+, d); Merge(A, e, q, d); 9

10 Exemplo MergeSort [25] [57] [48] [37] [2] [92] [86] [33] [25 57] [37 48] [2 92] [33 86] [ ] [ ] [ ] Algortmo Merge (ntercalação) Este algortmo faz fusão de duas lstas x[m],..., x[m2] e x[m2+],..., x[m3] em array y. As duas sublstas estão em ordens ncalmente. Merge (nt x[ ], nt m, nt m2, nt m3) nt y[ ]; nt apont, bpont, cpont; nt n, n2, n3; apont = m; bpont = m2+; for( cpont = m; apont <= m2 && bpont <= m3; cpont++) f (x[apont] < x[bpont]) y[cpont] = x[apont++]; else y[cpont] = x[bpont++]; whle (apont <= m2) y[cpont++] = x[apont++]; whle (bpont <= m3) y[cpont++] = x[bpont++]; 0

11 Efcênca de MergeSort T(n) = T(floor(n/2)) + T(celng(n/2)) + αn = O(n log n) Exge O(n) espaço adconal para o vetor auxlar 5 ORDENAÇÃO SEM OMPARAÇÃO 5. Ordenação por ontagem (ountng Sort) A déa básca de ountng Sort é determnar, para cada elemento x, o numero de elementos menor que x. Esta nformação pode ser usada para colocar o elemento x na posção correta. Por exemplo, se tem 7 elementos menor que x, então, x deve está na posção 7. Assume que cada elemento na lsta é um numero ntero entre e k. Assume que a entrada é um array A de n elementos. O array B aguarda a saída ordenada e o array é usada para armazenamento temporáro.

12 ountng-sort (nt A[ ], nt B[ ], nt k, nt n) for ( = ; <= k; ++) ) [] = 0; 2) for (j = ; j <= n; j++) 3) [A[j]] = [A[j]] + ; 4) /*agora [] contem o numero de elementos gual a. */ for ( = 2; <= k; ++) 5) [] = [] + [-]; 6) /*agora [] contem o numero de elementos menor ou gual a */ for (j = n; j >= ; j--) 7) B[[A[j]]] = A[j]; 8) [A[j]] = [A[j]] - ; 9) a) A d) B b) e) B c) B

13 f) A h) B g) ) B B j) B Efcênca de ountng Sort T lnha -2 (k) = O(k), T lnha 3-4 (n) = O(n), T lnha 5-6 (k) = O(k) e T lnha 7-9 (n) = O(n). Então, T(n) = O(n+k). Quando k = O(n), T(n) = O(n). Este algortmo exge dos arrays auxlares, um de tamanho n, outro de tamanho k. 3

14 5.2 Ordenação de Raízes (Radx Sort) Esta Ordenação basea-se nos valores dos dígtos nas representações posconas dos números sendo ordenados. Executa as seguntes ações pelo dgto menos sgnfcatvo e termnando com o mas sgnfcatvo. Pegue cada numero numero na seqüênca e poscone-o em uma das dez flas, dependendo do valor do dgto sendo processado. Em seguda, restaure cada fla para a seqüênca orgnal, começando pela fla de números com um dgto 0 e termnando com a fla de números com o dgto 9. Quando essas ações tverem sdo executadas para cada dgto, a seqüênca estará ordenada. Exemplo: Lsta orgnal: Flas baseadas no dgto menos sgnfcatvo nco fnal fla[0] fla[] fla[2] 2 92 fla[3] 33 fla[4] fla[5] 25 fla[6] 86 fla[7] fla[8] 48 fla[9] 4

15 Exemplo: Depos da prmera passagem: Flas baseadas no dgto mas sgnfcatvo nco fnal fla[0] fla[] 2 fla[2] 25 fla[3] fla[4] 48 fla[5] 57 fla[6] fla[7] fla[8] 86 fla[9] 92 Lsta classfcada: Algortmo for (k = dgto menos sgnfcatvo; k <= dgto mas sgnfcatvo; k++) for ( = 0; < n; ++) y = x[]; j = k-ésmo dgto de y; poscona y no fnal da fla[j]; for (qu = 0; qu < 0; qu++) coloca elementos da fla[qu] na próxma posção seqüencal; Obs.: os dados orgnas são armazenados no array x 5

16 Efcênca de Radx Sort Evdentemente, as exgêncas de tempo para o método de ordenação de raízes dependem da quantdade de dígtos (m) e do numero de elementos na lsta (n). omo a repetção mas externa é percorrda m vezes e a repetção mas nterna é percorrda n vezes. Então, T(n) = O(m*n). Se o numero de dígtos for menor, T(n) = O(n) Se as chaves forem densas (sto é, se quase todo numero que possa ser uma chave for de fato uma chave), m se aproxmara de logn. Neste caso, T(n) = O(nlogn). 6