SCC-601 Introdução à Ciência da Computação II. Ordenação e Complexidade Parte 3. Lucas Antiqueira

Transcrição

1 SCC-60 Introdução à Ciência da Computação II Ordenação e Complexidade Parte 3 Lucas Antiqueira

2 Ordenação:

3 Utiliza uma estrutura de dados chamada heap para ordenar. Um heap é um vetor (array) que representa uma árvore binária.

4 Heap: Estrutura de dados para armazenar dados segundo uma regra particular. Tradução usual: monte. ou Espaço de memória variável onde são criados objetos.

5 No caso da ordenação, um heap é uma estrutura de dados em que há uma ordenação entre elementos representados via árvore binária

6 Um heap observa conceitos de ordem e de forma Ordem: o item de qualquer nó deve satisfazer uma relação de ordem com os itens dos nós filhos Heap máximo (ou descendente): pai >= filhos, sendo que a raiz é o maior elemento Heap mínimo (ou heap ascendente): pai <= filhos, sendo que a raiz é o menor elemento 6

7 Heap Máximo

8 Um heap observa conceitos de ordem e de forma Forma: a árvore binária tem seus nós folha, no máximo, em dois níveis (ou seja, somente o último nível pode estar incompleto), sendo que as folhas devem estar o mais à esquerda possível 8

9 Nós folha? 9

10 Nós folha 0

11 Exemplos OK Não!

12 Exemplos de árvores binárias que não são heaps Por quê?

13 É um heap máximo Não é um heap máximo 3

14 ?? 4

15 Não é um heap máximo Não é um heap máximo 5

16 Como armazenar um heap? Filhos do nó i?

17 Como armazenar um heap? Filhos do nó i: - i + = filho esquerdo - i + = filho direito

18 Como armazenar um heap? Pai de um nó k?

19 Como armazenar um heap? Pai de um nó k? - Parte inteira de (k-)/ 7 8 9

20 Assume-se que: A raiz está sempre na posição 0 do vetor Teremos que armazenar o número de elementos do vetor e Teremos que armazenar o número de elementos no heap armazenado dentro do vetor 0

21 A idéia para ordenar usando um heap é: Construir um heap máximo Trocar a raiz o maior elemento com o elemento da última posição do vetor Diminuir o tamanho do heap em Rearranjar o heap máximo (agora menor), se necessário Repetir o processo n- vezes

22 : exemplo x[0]... x[7]... heap ) Monta-se o heap com base no vetor desordenado

23 : exemplo x[0]... x[7]... x[0]... x[6]... x[7] 9 heap heap ) Monta-se o heap com base no vetor desordenado 3 ) Troca-se a raiz (maior elemento) com o último elemento (x[7]) e rearranja-se o heap

24 : exemplo x[0]... x[7] x[0]... x[6] x[7] x[0]... x[5] x[6] x[7] heap heap heap ) Monta-se o heap com base no vetor desordenado 3) Troca-se a raiz com o último elemento (x[6]) e rearranja-se o heap 4 ) Troca-se a raiz (maior elemento) com o último elemento (x[7]) e rearranja-se o heap

25 : exemplo x[0]... x[7] x[0]... x[6] x[7] x[0]... x[5] x[6] x[7] heap heap heap ) Monta-se o heap com base no vetor desordenado 3) Troca-se a raiz com o último elemento (x[6]) e rearranja-se o heap 5 ) Troca-se a raiz (maior elemento) com o último elemento (x[7]) e rearranja-se o heap

26 O processo continua até todos os elementos terem sido incluídos no vetor de forma ordenada É necessário: Saber construir um heap a partir de um vetor qualquer Procedimento construir_heap Saber como rearranjar o heap, ou seja, manter a propriedade de heap máximo Procedimento rearranjar_heap 6

27 Procedimento rearranjar_heap: manutenção da propriedade de heap máximo Assume que as árvores binárias com raízes nos filhos esquerdo e direito de i são heap máximos, mas que A[i] pode ser menor que seus filhos, violando a propriedade de heap máximo A função do procedimento rearranjar_heap é deixar A[i] escorregar para a posição correta, de tal forma que a subárvore com raiz em i torne-se um heap máximo 7

28

29

30 Na prática, trabalha-se com o vetor Execução de rearranjar_heap Execução recursiva de rearranjar_heap

31 void rearranjar_heap(int v[], int i, int tamanho_do_heap) { int esq, dir, maior, aux; esq = * i + ; dir = * i + ; nó a partir do qual é necessário rearranjar if ((esq < tamanho_do_heap) && (v[esq] > v[i])) maior = esq; else maior = i; if ((dir < tamanho_do_heap) && (v[dir] > v[maior])) maior = dir; if (maior!= i) { aux = v[i]; v[i] = v[maior]; v[maior] = aux; rearranjar_heap(v, maior, tamanho_do_heap); } }

32 Procedimento construir_heap Percorre de forma ascendente os primeiros n/ - nós (que não são folhas) e executa o procedimento rearranjar_heap A cada chamada do rearranjar_heap para um nó, as duas árvores com raiz neste nó tornam-se heaps máximos Ao chamar o rearranjar_heap para a raiz, o heap máximo completo é obtido 3

33 n/ - =4 0 4 rearranjar_heap(a,4)

34 0 4 3 rearranjar_heap(a,3)

35 0 4 rearranjar_heap(a,)

36 rearranjar_heap(a,)

37 0 4 rearranjar_heap(a,0)

38 void construir_heap(int v[], int n) { int i; for (i = n/-; i >= 0; i--) rearranjar_heap(v, i, n); } Simulação (applet Java) em: 38

39 Procedimento heap-sort. Construir um heap máximo (via construir_heap). Trocar a raiz o maior elemento com o elemento da última posição do vetor 3. Diminuir o tamanho do heap em 4. Ajustar heap, se necessário (via rearranjar_heap) 5. Repetir o processo n- vezes 39

40 Dado o vetor: Chamar construir_heap e obter: Executar os passos de a 4 n vezes 40

41 void heapsort(int v[], int n) { int i, aux, tamanho_do_heap; construir_heap(v, n); tamanho_do_heap = n; for (i = n - ; i > 0; i--) { aux = v[0]; v[0] = v[i]; v[i] = aux; tamanho_do_heap--; rearranjar_heap(v, 0, tamanho_do_heap); } } 4

42 Executar o processo de ordenação completo para o vetor abaixo: (44, 55,, 4, 94) 4

43 é estável? 43

44 * + * + 44

45 * + * + * + * + 45

46 * + * + * + * + 46

47 * + * * * 47

48 + + * * + + * * 48

49 + + * * + * + * 49

50 + * Parte já ordenada, não vai mudar. A posição relativa desses dois números foi alterada. Heapsort é instável 50

51 Qual a complexidade do? 5

52 void rearranjar_heap(int v[], int i, int tamanho_do_heap) { int esq, dir, maior, aux; esq = * i + ; dir = * i + ; if ((esq < tamanho_do_heap) && (v[esq] > v[i])) maior = esq; else maior = i; 5 comparações if ((dir < tamanho_do_heap) && (v[dir] > v[maior])) maior = dir; if (maior!= i) { aux = v[i]; v[i] = v[maior]; v[maior] = aux; rearranjar_heap(v, maior, tamanho_do_heap); } }

53 rearranjar_heap 5 comparações realizadas no máximo log ( h) vezes, onde h é o número de elementos no heap log ( h) 53

54 void construir_heap(int v[], int n) { int i; for (i = n/-; i >= 0; i--) rearranjar_heap(v, i, n); } n / vezes 5 log ( n i) 54

55 construir_heap n / i= 5 log n n /... i= i= i=0 5 log ( n ) 5 log ( n ) 5 log ( n 0)

56 construir_heap n / i= 5 log n n /... i= i= i=0 5 log ( n ) 5 log ( n ) 5 log ( n 0) Soma?

57 Aproximação da soma: ) / ( 5 log ) ( 5 log ) ( 5 log ) ( log 5 n n n n n n j n n j n n j n n j j n j j / / / / ) ( log / 5 ) ( log 5 ) ( log 5 n n j j n / ) ( log 5 0 / 5 / ) ( log ) ( log 5 0 / 5 n j n j j j n! / log! 5 log 0 / 5 n n n?

58 log n! nlog n n Aproximação de Stirling! 5n / 0 5 log n! log n / n/ 0 5 nlog n n n / log n / / 5 n n/ 0 5nlog n 5n 5 n / log n / 5 / 0 5 n n5nlog n 5n 5n / 0log n / 0 5n / log n / 0log n / n Tconstruir _ heap( n) 5nlog n 5

59 log n! nlog n n Aproximação de Stirling! 5n / 0 5 log n! log n / n/ 0 5 nlog n n n / log n / / 5 n n/ 0 5nlog n 5n 5 n / log n / 5 / 0 5 n n5nlog n 5n 5n / 0log n / 0 5n / log n / 0log n / n Tconstruir _ heap( n) 5nlog n 5 T ( n) 5nlog n, para n 0 >= 69 construir_ heap

60 log n! nlog n n Aproximação de Stirling! 5n / 0 5 log n! log n / n/ 0 5 nlog n n n / log n / / 5 n n/ 0 5nlog n 5n 5 n / log n / 5 / 0 5 n n5nlog n 5n 5n / 0log n / 0 5n / log n / 0log n / n Tconstruir _ heap( n) 5nlog n 5 T ( n) 5nlog n, para n 0 >= 69 Portanto, T construir_heap (n) = O(nlog n) construir_ heap

61 void heapsort(int v[], int n) { int i, aux, tamanho_do_heap; construir_heap(v, n); tamanho_do_heap = n; for (i = n - ; i > 0; i--) { n- vezes aux = v[0]; v[0] = v[i]; v[i] = aux; tamanho_do_heap--; rearranjar_heap(v, 0, tamanho_do_heap); } } 6 5 log ( i) Onde i=tamanho_do_heap

62 n- vezes rearranjar_heap i=n log n i=3 i= i= 5 log 3 5 log 5 log Soma?

63 Aproximação da soma: log ( n ) 5log 3 5log 5log 5 n n n 5 j j j log ( j) 5 log ( j) 5 5log ( n )! 5( n )?

64 Aproximação da soma: log ( n ) 5log 3 5log 5log 5 n n n 5 j j j log ( j) 5 log ( j) 5 5log ( n )! 5( n ) 5( n )log ( n ) ( n ) 5( n ) log n! nlog n n T rearranjos_ heap ( n) 5( n )log ( n ) 4n 4 T ( n) 8nlog n, para n 0 >= 08 Portanto, T rearranjos_heap (n) = O(nlog n) rearranjos_ heap

65 T heapsort T heapsort ( n) Tconstruir _ heap( n) Trearranjos _ ( n) ( nlog n) ( nlog n ) heap ( n) T heapsort T heapsort ( n) max{ ( nlog n), ( nlog ( n ) ( n log n ) n )} 65

66 T heapsort T heapsort ( n) Tconstruir _ heap( n) Trearranjos _ ( n) ( nlog n) ( nlog n ) heap ( n) T heapsort T heapsort ( n) max{ ( nlog n), ( nlog ( n ) ( n log n ) n )} Pior caso do 66

67 Caso médio e melhor caso: ( nlog n) Uma análise detalhada em: R. Schaffer, R. Sedgewick. The Analysis of Heapsort. Journal of Algorithms, 5(), 76-00,

68 Caso médio e melhor caso: ( nlog n) Uma análise detalhada em: R. Schaffer, R. Sedgewick. The Analysis of Heapsort. Journal of Algorithms, 5(), 76-00, 993. Complexidade de espaço: (n) 68