Centro de Informá-ca Universidade Federal de Pernambuco. Vinicius Cardoso Garcia 2011 Vinicius Cardoso Garcia

Transcrição

1 Centro de Informá-ca Universidade Federal de Pernambuco Vinicius Cardoso Garcia

2 Problema Dados N números, arranjá los em ordem crescente ou decrescente (Sor-ng) Ordenar é dispor os elementos de um conjunto em uma ordem ascendente ou descendente Mo-vação O-mização de alguns processos Ex.: busca 2

3 3

4 Humanos fazem ordenação de forma eficiente em muitos casos Humanos podem ver todos os jogadores de uma vez e rapidamente rearranjar os elementos de forma ad hoc Computadores conseguem apenas comparar dois elementos por vez 4

5 Muito lento, mas bastante intui-vo! Simples de entender. A idéia básica: 1. Compare dois elementos 2. Se o da esquerda for maior, troque os de lugar 3. Avance uma posição e volte ao passo 1 Isso colocará o maior elemento na úl-ma posição. Para ordenar os demais basta repe-r esse processo. 5

6 Ordenação: Parte I 6

7 7

8 public void bubblesort(int[] a) { int in, out; int n=a.length; for(out=n 1; out>1; out ) for(in=0; in<out; in++) if (a[in] > a[in+1]) swap(a, in, in+1); } 8

9 Para 10 elementos temos que fazer 45 comparações Em geral, se N for o número de itens do arranjo temos N*(N 1)/2 comparações. Portanto, a eficiência do Bubble Sort é O(n 2 ) Podemos melhorar? O que poderia ser mudado? 9

10 Idéia semelhante ao Bubble Sort Nesse caso vamos ser um pouco mais inteligentes Será que é preciso trocar os elementos de imediato? Podemos reduzir a quan-dade de swap! 10

11 Algoritmo Selecione o menor item do vetor Troque o com o item da primeira posição do vetor Repita essas duas operações com os n 1 itens restantes, depois com os n 2 itens, até que reste apenas um elemento 11

12 O método é ilustrado abaixo As chaves em negrito sofreram uma troca entre si 12

13 13

14 public void selecfonsort(int[] a) { int in, out, min; int n=a.length; for(out=0; out<n 1; out++) { min = out; for(in=out+1; in<n; in++) if (a[in] < a[min]) min=in; swap(a, out, min); } } 14

15 Vantagens Custo linear para o número de movimentos de registros É o algoritmo a ser u-lizado para arquivos com registros muito grandes É muito interessante par arquivos pequenos Desvantagens O fato de o arquivo já estar ordenado não ajuda em nada, pois o custo con-nua quadrá-co O algoritmo não é estável 15

16 Podemos observar que o número de swaps no Selec-on Sort é menor que no Bubble Sort. No entanto, temos o mesmo número de comparações! Na prá-ca o Selec-on Sort é mais rápido mas, ainda assim, seu custo é O(n 2 ). 16

17 Método preferido dos jogadores de cartas Algoritmo Em cada passo a par-r de i=2 faça: Selecione o i ésimo item da seqüência fonte Coloque o no lugar apropriado na seqüência des-no de acordo com o critério de ordenação 17

18 Vamos imaginar um arranjo de elementos parcialmente ordenados. v1 v4 v6 v7 v5 v2 v8 v3 v10 v9 Parte Ordenada Parte Não Ordenada Elemento da Vez 18

19 v1 v4 v6 v7 v5 v2 v8 v3 v10 v9 Elemento da Vez v1 v4 v6 v7 v2 v8 v3 v10 v9 v1 v4 v5 v6 v7 v2 v8 v3 v10 v9 19

20 public void inserfonsort(int[] a) { int in, davez, n=a.length; for (davez=1; davez<n; davez++) { in=davez 1; double temp=a[davez]; while (in>=0 && a[in]>=temp) { a[in+1] = a[in]; in = in 1; } a[in+1]=temp; } } 20

21 Observamos que o número de comparações máximo para cada elemento ainda não ordenado do vetor é dado pela quan-dade de elementos a sua esquerda. Ou seja, no úl-mo elemento, teremos N 1 comparações no pior caso. Portanto, a complexidade é O(n 2 ). 21

22 A idéia do mergesort tem como base dois princípios: Recursão Abordagem dividir para conquistar 1. Dividir o problema em sub-problemas (menores) 2. Resolver estas novas instâncias (recursivamente) 3. Intercalar os resultados desses sub-problemas para achar a solução do problema principal. 22

23 23

24 v3 v1 v5 v2 v7 v4 v6 v8 v3 v1 v5 v2 v7 v4 v6 v8 v3 v1 v5 v2 v7 v4 v6 v8 v1 v3 v5 v2 v7 v4 v6 v8 v1 v3 v2 v5 v7 v4 v6 v8 v1 v2 v3 v5 v7 v4 v6 v8 24

25 v1 v2 v3 v5 v7 v4 v6 v8 v1 v2 v3 v5 v7 v4 v6 v8 v1 v2 v3 v5 v4 v7 v6 v8 v1 v2 v3 v5 v4 v7 v6 v8 v1 v2 v3 v5 v4 v6 v7 v8 v1 v2 v3 v4 v5 v6 v7 v8 25

26 void mergesort(int[] v, int ini, int fim) { if(ini == fim) // tamanho = 1 return; else { // encontra o meio int meio = (ini+fim) / 2; // ordena 1a metade mergesort(v, ini, meio); // ordena 2a metade mergesort(v, meio+1, fim); // intercala merge(v, ini, meio+1, fim); } // end else } 26

27 v1 v2 v3 v5 v1 v2 v3 v4 v5 v6 v7 v8 v4 v6 v7 v8 27

28 void merge(int[] v, int inicio, int meio, int fim) { int fim2 = fim; int fim1 = ini2,ini1 = inicio,ini2 = meio,ci = 0; int[] c = new int[fim inicio+1]; while (ini1<fim1 && ini2<fim2) { if (v[ini1] <= v[ini2]) { c[ci] = v[ini1]; ini1++; } else { c[ci] = v[ini2]; ini2++; } ci++; } 28

29 void merge(int[] v, int ini1, int ini2, int fim) {... while (ini1<fim1) { c[ci] = v[ini1]; ini1++; ci++; } while (ini2<fim2) { c[ci] = v[ini2]; ini2++; ci++; } for (int i=0; i<c.length; i++) v[inicio+i] = c[i]; } 29

30 É constatado que a eficiência do mergesort é da O(n*log n) Isso é muito mais eficiente que os algoritmos anteriores, que eram O(n 2 )! Ex: se n= então n 2 = n*log n =