Ordenação - PowerPoint PPT Presentation

ordena o n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Ordenação PowerPoint Presentation
Download Presentation
Ordenação

play fullscreen
1 / 41
Ordenação
226 Views
Download Presentation
dillon
Download Presentation

Ordenação

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Ordenação IF672 - Algoritmos e Estruturas de Dados CIn - UFPE if672.ufpe@gmail.com

  2. Ordenação • Ordenar é dispor os elementos em ordem ascendente ou descendente. • Dados n números, arranjá-los em ordem crescente. • Sortings: • Heapsort • Quicksort • Mergesort

  3. Heapsort • Ordenação de um conjunto de elementos com um heap. • Primeiro passo: construção do heap. • Selecionamos e posicionamos o maior elemento do conjunto, trocando o primeiro com o último elemento. • Decrementamos o tamanho do heap. • Rearranjamos o heap. • Continua com as sucessivas trocas do primeiro com o último elemento e rearranjos do heap.

  4. Heapsort • Após tudo isso, o array é visto como contendo um heap mais a parte da solução. • Então, o uso da estrutura heap permite que: • O elemento máximo do conjunto seja determinado e corretamente posicionado no vetor em tempo constante, trocando o primeiro elemento do heap com o último. • Número de trocas de elementos proporcional à altura da árvore.

  5. 74 41 34 21 9 22 26 74 22 41 21 9 34 26 41 26 34 21 9 22 74  74 41 41 34 26 34 21 9 22 26 21 9 22 74 Heapsort

  6. 41 26 34 21 9 22 74 34 26 22 21 9 41 74 41 26 34 21 9 22 74 41 34 26 34 26 22  21 9 22 74 21 9 41 74 Heapsort

  7. 34 26 22 21 9 41 74 26 21 22 9 34 41 74 34 26 22 21 9 41 74 34 26 26 22 21 22  21 9 41 74 9 34 41 74 Heapsort

  8. 26 21 22 9 34 41 74 22 21 9 26 34 41 74 26 21 22 9 34 41 74 26 22 21 22 21 9  9 34 41 74 26 34 41 74 Heapsort

  9. 22 21 9 26 34 41 74 21 9 22 26 34 41 74 22 21 9 26 34 41 74 22 21 21 9 9 22  26 34 41 74 26 34 41 74 Heapsort

  10. 21 9 22 26 34 41 74 9 21 22 26 34 41 74 21 9 22 26 34 41 74 21 9 9 22 21 22  26 34 41 74 26 34 41 74 Heapsort

  11. Heapsort • Chamada: • Implementação: heapsort(array, array.length); void heapsort (int array[], int n) { constroiHeap (array, n); int tamanhoDoHeap = n; for(int i = n-1; i>0; i--) { troca (array[0], array[i]); --tamanhoDoHeap; heapfy (array,tamanhoDoHeap,0); } }

  12. Quicksort • Ordenação simples de implementar em linguagens com recursão. • Método “dividir para conquistar”. • Particiona o arquivo em duas partes, ordenando as partes independentes.

  13. Quicksort • Dividir para Conquistar • Dividir: • Particione o array em dois subarrays ao redor de um pivô x de forma que elementos no subarray inferior ≤x≤ elmentos no subarray superior. • Obs: a posição do elementos iguais à chave deve ser especificada, dependendo do objetivo da implementação.

  14. Quicksort • Escolha um elemento (pivô) e coloque-o no início da lista. • Varra o array a partir da esquerda até encontrar um elemento que seja maior que o pivô e pela direita até encontrar um elemento menor que o pivô. • Os dois devem ser trocados de lugar. • Quando os ponteiros se cruzam, troque o pivô com o elemento mais a esquerda do array.

  15. Quicksort: Exemplo Particiona

  16. Quicksort: Exemplo Particiona

  17. Quicksort: Exemplo Particiona

  18. Quicksort: Exemplo Particiona

  19. Quicksort: Exemplo Particiona

  20. Quicksort: Exemplo Particiona

  21. Quicksort Função Particiona Implementação: int particiona (int array[], int i, int f) { int a = i+1; int b = f; int pivo = array[i]; while(a <= b) { while(a<=f && array[a]<pivo) a++; while(array[b]>pivo) b--; if(a < b) troca (array[a], array[b]); } troca(array[b], array[i]); return b; }

  22. Quicksort Chamada: Implementação: quicksort(array, 0, array.length-1); void quicksort (int array[], int i, int f) {if (i < f) { int p = particiona (array, i, f); quicksort (array, i, p-1); quicksort (array, p+1, f); } }

  23. Quicksort • Considerações finais • Quicksort é um ótimo algoritmo de ordenação de propósito geral. • Quicksort é normalmente mais rápido que o Mergesort, mas no pior caso tem custo O(n²).

  24. Mergesort Algoritmo particular de ordenação. Método “dividir para conquistar”. Divide o array no meio. Ordena cada metade com Mergesort novamente. Junta (merge) as partes já ordenadas. Problema: necessita de um espaço igual ao dobro do tamanho da lista a ser ordenada.

  25. 82 70 11 72 25 36 44 10 82 70 11 72 25 36 44 10 82 70 11 72 25 36 44 10 Mergesort 82 70 11 72 25 36 44 10

  26. 10 11 25 36 44 70 72 82 11 70 72 82 10 25 36 44 70 82 11 72 25 36 10 44 Mergesort 82 70 11 72 25 36 44 10

  27. Mergesort Chamada: Implementação: mergesort(array, 0, array.length-1); void mergesort(int array[], int i, int f) { if (i < f) { int mid = (i+f)/2; mergesort (array, i, mid); mergesort (array, mid+1, f); intercala (array, i, mid, f); }

  28. 11 70 72 82 10 25 36 44 Mergesort Função Merge/Intercala a b Divisão da direita Divisão da esquerda

  29. 10 11 70 72 82 10 25 36 44 Mergesort Função Merge/Intercala a b Divisão da direita Divisão da esquerda

  30. 10 11 11 70 72 82 10 25 36 44 Mergesort Função Merge/Intercala a b Divisão da direita Divisão da esquerda

  31. 10 11 25 11 70 72 82 10 25 36 44 Mergesort Função Merge/Intercala a b Divisão da direita Divisão da esquerda

  32. 10 11 25 36 11 70 72 82 10 25 36 44 Mergesort Função Merge/Intercala a b Divisão da direita Divisão da esquerda

  33. 10 11 25 36 44 11 70 72 82 10 25 36 44 Mergesort Função Merge/Intercala a b Divisão da direita Divisão da esquerda

  34. 10 11 25 36 44 70 72 82 11 70 72 82 10 25 36 44 Mergesort Função Merge/Intercala a b Divisão da direita Divisão da esquerda

  35. Mergesort Implementação Merge/Intercala void intercala (int array[], int left, int mid, int right) {int i = left; int j = mid + 1; int k = left - 1; while (i <= mid && j <= right) { k++; if (array[i] <= array[j]) { temp[k] = array[i]; i++; } else { temp[k] = array[j]; j++; } } //...}

  36. Mergesort Implementação Merge/Intercala void intercala (int array[], int left, int mid, int right) {while (i <= mid) { temp[k] = array[i]; i++; k++; } while (j <= right) { temp[k] = array[j]; j++; k++; } }

  37. x < A x > A B A C x < B x > B x < C x > C Relembrando:Busca Binária Busca eficiente feita em um array ordenado. A busca é iniciada pelo elemento central. Se o elemento procurado for menor, procura-se novamente na primeira metade, caso contrário, na segunda.

  38. 1 2 4 5 8 10 11 20 25 32 33 37 39 46 50 8 < 20 i = 0 m = 7 f = 14 8 > 5 1 2 4 5 8 10 11 i = 0 m = 3 f = 6 8 10 11 8 < 10 i = 0 f = 6 m = 5 8 i = m = f = 5 Relembrando:Busca Binária Busca bem sucedida: número 8

  39. 1 2 4 5 8 10 11 20 25 32 33 37 39 46 50 28 > 20 i = 0 m = 7 f = 14 25 32 33 37 39 46 50 28 < 37 i = 8 m = 11 f = 14 25 32 33 28 < 32 i = 8 f = 10 m = 9 25 i = m = f = 8 Relembrando:Busca Binária Busca mal sucedida: número 28

  40. Relembrando:Busca Binária Chamada: Implementação: bs(array, 0, array.length-1, x); int bs(int array[], int i, int f, int x) {int mid = (i+f)/2; if (x == array[mid]) // caso base 1 (encontrado) return mid; else if (i >= f) // caso base 2 (não existe) return –1; else if (x < array[mid]) // caso indutivo return bs(array, i, mid-1, x) else return bs(array, mid+1, f, x)}

  41. Ordenação IF672 - Algoritmos e Estruturas de Dados CIn - UFPE if672.ufpe@gmail.com