Porquê estudar algoritmos elementares (de ordenação)

Transcrição

1 Algoritmos e Estruturas de Dados LEE 2014/2015 Algoritmos de Ordenação Parte I Porquê estudar algoritmos elementares (de ordenação) Razões de ordem prática Fáceis de codificar e por vezes suficientes Rápidos/Eficientes para problemas de dimensão média e por vezes os melhores em certas circunstâncias Razões pedagógicas Bom exemplo para aprender terminologia, compreender contexto dos problemas e bom princípios para desenvolvimento de algoritmos mais sofisticados Alguns são fáceis de generalizar para métodos mais eficientes ou para melhorar o desempenho de outros algoritmos Importante para compreensão das regras de "funcionamento" 2 1

2 Contexto e regras básicas [1] Objectivo Estudar métodos de ordenação de ficheiros de dados em que cada elemento (item) é caracterizado por uma chave ("key") Chaves são usadas para controlar a ordenação objectivo é rearranjar os dados de forma a que as chaves estejam ordenadas de forma pré-definida (numérica ou alfabética, por exemplo) Opções em termos de implementação macros ou subrotinas/funções? compromisso entre desempenho, generalidade e simplicidade utilizaremos uma mistura de ambos 3 Contexto e regras básicas [2] Metodologia características específicas de cada item ou chave podem ser diferentes mas conceito abstracto é o mais importante começaremos por estudar ordenação em tabelas utilizaremos operações abstractas nos dados: comparação, troca alterar items para outro tipo (ex: vírgula flutuante) é simples typedef int Item; #define key(a) (A) #define less(a, B) (key(a) < key(b)) #define exch(a, B) {Item t = A; A = B; B = t; } #define compexch(a, B) if (less(b,a)) exch(a, B) Tempo de execução usualmente proporcional ao número de comparações número de movimentações/trocas (ou ambos) 4 2

3 Nomenclatura [1] Tipos de Algoritmos de Ordenação não adaptativos: sequência de operações independente da ordenação original dos dados interessantes para implementação em hardware adaptativos: sequência de operações dependente do resultado de comparações (operação "less") a maioria dos que estudaremos Parâmetro de interesse é o desempenho, i.e. tempo de execução algoritmos básicos: N 2 para ordenar N items mas por vezes os melhores para N pequeno algoritmos avançados: N log N para ordenar N items Olharemos também para os recursos de memória necessários ordenação "in-place" ou utilizando memória adicional 5 Nomenclatura [2] Definição um algoritmo de ordenação é dito estável se preserva a ordem relativa dos items com chaves repetidas exemplo: ordenar lista de alunos por ano de graduação quando esta já está ordenada alfabeticamente por nome é usualmente possível estabilizar um algoritmo alterando a sua chave (tem custo adicional) algoritmos básicos são quase todos estáveis, mas poucos algoritmos avançados são estáveis 6 3

4 Nomenclatura [3] Definição um algoritmo de ordenação é dito interno, se o conjunto de todos os dados a ordenar couber na memória; caso contrário é dito externo ex: ordenar dados lidos de tape ou disco é ordenação externa Distinção muito importante: ordenação interna pode aceder a qualquer dado facilmente ordenação externa tem de aceder a dados de forma sequencial (ou em blocos) Vamos estudar fundamentalmente ordenação interna 7 Nomenclatura [4] Definição um algoritmo de ordenação é dito directo se os dados são acedidos directamente nas operações de comparação e troca; caso contrário é dito indirecto Exemplo de algoritmo indirecto: se a chave for pequena e cada dado for "grande (por exemplo o nome completo de um aluno, mais morada, número de BI, etc) nestes casos não convém estar a trocar os elementos é dispendioso basta trocar a informação correspondente aos seus índices tabela de índices/ponteiros em que o primeiro indica o menor elemento, etc 8 4

5 Contexto de utilização XXX Mesmo programa, diferentes drivers para diferentes algoritmos #include <stdio.h> #include <stdlib.h> main (int argc, char *argv[]){ int i, N = atoi (argv[1]), sw = atoi (argv[2]); int *a = malloc (N * sizeof(int)); } if (sw) for (i = 0; i < N; i++) a[i] = 1000 * (1.0 * rand() / RAND_MAX); else while (scanf( %d, &a[n]) == 1) N++; sort (a, 0, N-1); for (i = 0; i < N; i++) printf( %3d, a[i]); printf( \n ); Para cada algoritmo, sort tem nome apropriado 9 Contexto de utilização Mesmo programa, diferentes drivers para diferentes algoritmos #include <stdio.h> #include <stdlib.h> #define N_ELEMS main (){ int i, sw, N = N_ELEMS; int a[n_elems]; } scanf( %d, &sw); if (sw) for (i = 0; i < N; i++) a[i] = 1000 * (1.0 * rand() / RAND_MAX); else{ N = 0; while (scanf( %d, &a[n]) == 1) N++; } sort (a, 0, N-1); for (i = 0; i < N; i++) printf( %3d, a[i]); printf( \n ); Para cada algoritmo, sort tem nome apropriado 10 5

6 Ordenação por selecção - Selection Sort Um dos mais simples Algoritmo procurar menor elemento e trocar com o elemento na 1 a posição procurar 2 o menor elemento e trocar com o elemento na 2 a posição proceder assim até ordenação estar completa void selection (Item a[], int l, int r) { int i, j; } for (i = l; i < r; i++) { int min = i; for (j = i+1; j <= r; j++) if (less(a[j], a[min])) min = j; exch(a[i], a[min]) } Ciclo exterior... Ciclo interior 11 Selection Sort - Exemplo de Aplicação 12 6

7 Selection Sort - Exemplo de Aplicação 13 Selection Sort - Exemplo de Aplicação A A O R T I N G E X S M P L E 14 7

8 Selection Sort - Exemplo de Aplicação A A O R T I N G E X S M P L E A A E R T I N G O X S M P L E 15 Selection Sort - Exemplo de Aplicação A A O R T I N G E X S M P L E A A E R T I N G O X S M P L E A A E E T I N G O X S M P L R 16 8

9 Selection Sort - Exemplo de Aplicação A A O R T I N G E X S M P L E A A E R T I N G O X S M P L E A A E E T I N G O X S M P L R A A E E G I N T O X S M P L R 17 Selection Sort - Exemplo de Aplicação A A O R T I N G E X S M P L E A A E R T I N G O X S M P L E A A E E T I N G O X S M P L R A A E E G I N T O X S M P L R A A E E G I N T O X S M P L R 18 9

10 Selection Sort - Exemplo de Aplicação A A O R T I N G E X S M P L E A A E R T I N G O X S M P L E A A E E T I N G O X S M P L R A A E E G I N T O X S M P L R A A E E G I N T O X S M P L R A A E E G I L T O X S M P N R 19 Selection Sort - Exemplo de Aplicação A A O R T I N G E X S M P L E A A E R T I N G O X S M P L E A A E E T I N G O X S M P L R A A E E G I N T O X S M P L R A A E E G I N T O X S M P L R A A E E G I L T O X S M P N R A A E E G I L M O X S T P N R 20 10

11 Selection Sort - Exemplo de Aplicação A A O R T I N G E X S M P L E A A E R T I N G O X S M P L E A A E E T I N G O X S M P L R A A E E G I N T O X S M P L R A A E E G I N T O X S M P L R A A E E G I L T O X S M P N R A A E E G I L M O X S T P N R A A E E G I L M N X S T P O R 21 Selection Sort - Exemplo de Aplicação A A O R T I N G E X S M P L E A A E R T I N G O X S M P L E A A E E T I N G O X S M P L R A A E E G I N T O X S M P L R A A E E G I N T O X S M P L R A A E E G I L T O X S M P N R A A E E G I L M O X S T P N R A A E E G I L M N X S T P O R A A E E G I L M N O S T P X R 22 11

12 Selection Sort - Exemplo de Aplicação A A O R T I N G E X S M P L E A A E R T I N G O X S M P L E A A E E T I N G O X S M P L R A A E E G I N T O X S M P L R A A E E G I N T O X S M P L R A A E E G I L T O X S M P N R A A E E G I L M O X S T P N R A A E E G I L M N X S T P O R A A E E G I L M N O S T P X R A A E E G I L M N O P T S X R 23 Selection Sort - Exemplo de Aplicação A A O R T I N G E X S M P L E A A E R T I N G O X S M P L E A A E E T I N G O X S M P L R A A E E G I N T O X S M P L R A A E E G I N T O X S M P L R A A E E G I L T O X S M P N R A A E E G I L M O X S T P N R A A E E G I L M N X S T P O R A A E E G I L M N O S T P X R A A E E G I L M N O P T S X R A A E E G I L M N O P R S X T 24 12

13 Selection Sort - Exemplo de Aplicação A A O R T I N G E X S M P L E A A E R T I N G O X S M P L E A A E E T I N G O X S M P L R A A E E G I N T O X S M P L R A A E E G I N T O X S M P L R A A E E G I L T O X S M P N R A A E E G I L M O X S T P N R A A E E G I L M N X S T P O R A A E E G I L M N O S T P X R A A E E G I L M N O P T S X R A A E E G I L M N O P R S X T A A E E G I L M N O P R S X T 25 Selection Sort - Exemplo de Aplicação A A O R T I N G E X S M P L E A A E R T I N G O X S M P L E A A E E T I N G O X S M P L R A A E E G I N T O X S M P L R A A E E G I N T O X S M P L R A A E E G I L T O X S M P N R A A E E G I L M O X S T P N R A A E E G I L M N X S T P O R A A E E G I L M N O S T P X R A A E E G I L M N O P T S X R A A E E G I L M N O P R S X T A A E E G I L M N O P R S X T A A E E G I L M N O P R S T X 26 13

14 Selection Sort - Exemplo de Aplicação A A O R T I N G E X S M P L E A A E R T I N G O X S M P L E A A E E T I N G O X S M P L R A A E E G I N T O X S M P L R A A E E G I N T O X S M P L R A A E E G I L T O X S M P N R A A E E G I L M O X S T P N R A A E E G I L M N X S T P O R A A E E G I L M N O S T P X R A A E E G I L M N O P T S X R A A E E G I L M N O P R S X T A A E E G I L M N O P R S X T A A E E G I L M N O P R S T X A A E E G I L M N O P R S T X 27 Selection Sort - Exemplo de Aplicação A A O R T I N G E X S M P L E A A E R T I N G O X S M P L E A A E E T I N G O X S M P L R A A E E G I N T O X S M P L R A A E E G I N T O X S M P L R A A E E G I L T O X S M P N R A A E E G I L M O X S T P N R A A E E G I L M N X S T P O R A A E E G I L M N O S T P X R A A E E G I L M N O P T S X R A A E E G I L M N O P R S X T A A E E G I L M N O P R S X T A A E E G I L M N O P R S T X A A E E G I L M N O P R S T X 28 14

15 Selection Sort - Análise Ciclo interno apenas faz comparações troca de elementos é feita fora do ciclo interno cada troca coloca um elemento na sua posição final número de trocas é N-1 (porque não N?) tempo de execução dominado pelo número de comparações! Propriedade Selection sort usa aproximadamente N 2 /2 comparações e N trocas Demonstração para cada item i de 1 a N-1 há uma troca e N-i comparações (ver zona não sombreada no exemplo) Logo há N-1 trocas e (N-1)+(N-2) =N(N-1)/2 comparações Factos desempenho é independente da ordenação inicial dos dados; a única coisa que depende desta ordenação é o número de vezes que min é actualizado (quadrático no pior caso, NlogN em média) 29 Ordenação por inserção - Insertion Sort Ideia: considerar os elementos um a um e inseri-los no seu lugar entre os elementos já tratados (mantendo essa ordenação) ex: ordenar cartas de jogar inserção implica arranjar novo espaço ou seja mover um número elevado de elementos uma posição para a direita inserir os elementos um a um começando pelo da 1 a posição #define less(a, B) (key(a) < key(b)) #define exch(a, B) {Item t = A; A = B; B = t; } #define compexch(a, B) if (less(b,a)) exch(a, B) void insertion(item a[], int l, int r) { int i, j; Ciclo exterior... Ciclo interior } for (i = l+1; i <= r; i++) for (j = i; j > l; j--) compexch (a[j-1], a[j]); 30 15

16 Insertion Sort - Comentários Elementos à esquerda do índice corrente, i, estão ordenados mas não necessariamente na sua posição final podem ainda ter de ser deslocados para a direita para dar lugar a elementos menores encontrados posteriormente Implementação da ordenação por inserção no acetato anterior é ineficiente código é simples, claro mas pouco eficiente; pode ser melhorado ilustra bom raciocínio: encontrar solução simples estudar o seu funcionamento melhorar desempenho através de pequenas transformações 31 Insertion Sort - Melhorar desempenho Demasiadas operações de comparação/troca (compexch) podemos parar se encontramos uma chave que não é maior que a do item a ser inserido (tabela está ordenada à esquerda) podemos sair do ciclo interno se less(a[j-1], a[j]) é verdadeira modificação torna o algoritmo adaptativo aumenta desempenho aproximadamente por um factor de 2 Passa a haver duas condições para sair do ciclo mudar para um ciclo while remover instruções irrelevantes compexch não é o melhor processo de mover vários dados uma posição para a direita 32 16

17 Insertion Sort - Versão adaptativa void insertion(item a[], int l, int r) { int i, j; } for (i = l+1; i <= r; i++) for (j = i; j > l; j--) compexch (a[j-1], a[j]); void insertion(item a[], int l, int r) { int i, j; } for (i = l+1; i <= r; i++) { Item v = a[i]; j = i; while (j > l && less(v, a[j-1])) { exch(a[j], a[j-1]); j--; } a[j] = v; } 33 Insertion Sort - Exemplo de Aplicação 34 17

18 Insertion Sort - Exemplo de Aplicação 35 Insertion Sort - Exemplo de Aplicação A O S R T I N G E X A M P L E 36 18

19 Insertion Sort - Exemplo de Aplicação A O S R T I N G E X A M P L E A O R S T I N G E X A M P L E 37 Insertion Sort - Exemplo de Aplicação A O S R T I N G E X A M P L E A O R S T I N G E X A M P L E A O R S T I N G E X A M P L E 38 19

20 Insertion Sort - Exemplo de Aplicação A O S R T I N G E X A M P L E A O R S T I N G E X A M P L E A O R S T I N G E X A M P L E A I O R S T N G E X A M P L E 39 Insertion Sort - Exemplo de Aplicação A O S R T I N G E X A M P L E A O R S T I N G E X A M P L E A O R S T I N G E X A M P L E A I O R S T N G E X A M P L E A I N O R S T G E X A M P L E 40 20

21 Insertion Sort - Exemplo de Aplicação A O S R T I N G E X A M P L E A O R S T I N G E X A M P L E A O R S T I N G E X A M P L E A I O R S T N G E X A M P L E A I N O R S T G E X A M P L E A G I N O R S T E X A M P L E 41 Insertion Sort - Exemplo de Aplicação A O S R T I N G E X A M P L E A O R S T I N G E X A M P L E A O R S T I N G E X A M P L E A I O R S T N G E X A M P L E A I N O R S T G E X A M P L E A G I N O R S T E X A M P L E A E G I N O R S T X A M P L E 42 21

22 Insertion Sort - Exemplo de Aplicação A O S R T I N G E X A M P L E A O R S T I N G E X A M P L E A O R S T I N G E X A M P L E A I O R S T N G E X A M P L E A I N O R S T G E X A M P L E A G I N O R S T E X A M P L E A E G I N O R S T X A M P L E A E G I N O R S T X A M P L E 43 Insertion Sort - Exemplo de Aplicação A O S R T I N G E X A M P L E A O R S T I N G E X A M P L E A O R S T I N G E X A M P L E A I O R S T N G E X A M P L E A I N O R S T G E X A M P L E A G I N O R S T E X A M P L E A E G I N O R S T X A M P L E A E G I N O R S T X A M P L E A A E G I N O R S T X M P L E 44 22

23 Insertion Sort - Exemplo de Aplicação A O S R T I N G E X A M P L E A O R S T I N G E X A M P L E A O R S T I N G E X A M P L E A I O R S T N G E X A M P L E A I N O R S T G E X A M P L E A G I N O R S T E X A M P L E A E G I N O R S T X A M P L E A E G I N O R S T X A M P L E A A E G I N O R S T X M P L E A A E G I M N O R S T X P L E 45 Insertion Sort - Exemplo de Aplicação A O S R T I N G E X A M P L E A O R S T I N G E X A M P L E A O R S T I N G E X A M P L E A I O R S T N G E X A M P L E A I N O R S T G E X A M P L E A G I N O R S T E X A M P L E A E G I N O R S T X A M P L E A E G I N O R S T X A M P L E A A E G I N O R S T X M P L E A A E G I M N O R S T X P L E A A E G I M N O P R S T X L E 46 23

24 Insertion Sort - Exemplo de Aplicação A O S R T I N G E X A M P L E A O R S T I N G E X A M P L E A O R S T I N G E X A M P L E A I O R S T N G E X A M P L E A I N O R S T G E X A M P L E A G I N O R S T E X A M P L E A E G I N O R S T X A M P L E A E G I N O R S T X A M P L E A A E G I N O R S T X M P L E A A E G I M N O R S T X P L E A A E G I M N O P R S T X L E A A E G I L M N O P R S T X E 47 Insertion Sort - Exemplo de Aplicação A O S R T I N G E X A M P L E A O R S T I N G E X A M P L E A O R S T I N G E X A M P L E A I O R S T N G E X A M P L E A I N O R S T G E X A M P L E A G I N O R S T E X A M P L E A E G I N O R S T X A M P L E A E G I N O R S T X A M P L E A A E G I N O R S T X M P L E A A E G I M N O R S T X P L E A A E G I M N O P R S T X L E A A E G I L M N O P R S T X E A A E E G I L M N O P R S T X 48 24

25 Insertion Sort - Exemplo de Aplicação A O S R T I N G E X A M P L E A O R S T I N G E X A M P L E A O R S T I N G E X A M P L E A I O R S T N G E X A M P L E A I N O R S T G E X A M P L E A G I N O R S T E X A M P L E A E G I N O R S T X A M P L E A E G I N O R S T X A M P L E A A E G I N O R S T X M P L E A A E G I M N O R S T X P L E A A E G I M N O P R S T X L E A A E G I L M N O P R S T X E A A E E G I L M N O P R S T X A A E E G I L M N O P R S T X 49 Insertion Sort - Análise Propriedade Insertion sort usa aproximadamente N 2 /4 comparações e N 2 /4 pseudo-trocas (translações ou movimentos) no caso médio e o dobro destes valores no pior caso Demonstração Fácil de ver graficamente; elementos abaixo da diagonal são contabilizados (todos no pior caso) Para dados aleatórios é expectável que cada elemento seja colocado aproximadamente a meio para trás pelo que apenas metade dos elementos abaixo da diagonal devem ser contabilizados Factos em certos casos Insertion sort pode ter bom desempenho (a ver...) 50 25

26 Bubble Sort Talvez o algoritmo mais utilizado e o que muitas pessoas aprendem Ideia fazer múltiplas passagens pelos dados trocando de cada vez dois elementos adjacentes que estejam fora de ordem, até não haver mais trocas supostamente muito fácil de implementar usualmente mais lento que os dois métodos elementares estudados void bubble(item a[], int l, int r) { int i, j; for (i = l; i < r; i++) for (j = r; j > i; j--) compexch(a[j-1], a[j]); } Ciclo exterior... Ciclo interior 51 Bubble Sort - Exemplo de Aplicação (Ciclo interior) 52 26

27 Bubble Sort - Exemplo de Aplicação (Ciclo interior) A S O R T I N G E X A M P E L 53 Bubble Sort - Exemplo de Aplicação (Ciclo interior) A S O R T I N G E X A M P E L A S O R T I N G E X A M E P L 54 27

28 Bubble Sort - Exemplo de Aplicação (Ciclo interior) A S O R T I N G E X A M P E L A S O R T I N G E X A M E P L A S O R T I N G E X A E M P L 55 Bubble Sort - Exemplo de Aplicação (Ciclo interior) A S O R T I N G E X A M P E L A S O R T I N G E X A M E P L A S O R T I N G E X A E M P L A S O R T I N G E X A E M P L 56 28

29 Bubble Sort - Exemplo de Aplicação (Ciclo interior) A S O R T I N G E X A M P E L A S O R T I N G E X A M E P L A S O R T I N G E X A E M P L A S O R T I N G E X A E M P L A S O R T I N G E A X E M P L 57 Bubble Sort - Exemplo de Aplicação (Ciclo interior) A S O R T I N G E X A M P E L A S O R T I N G E X A M E P L A S O R T I N G E X A E M P L A S O R T I N G E X A E M P L A S O R T I N G E A X E M P L A S O R T I N G A E X E M P L 58 29

30 Bubble Sort - Exemplo de Aplicação (Ciclo interior) A S O R T I N G E X A M P E L A S O R T I N G E X A M E P L A S O R T I N G E X A E M P L A S O R T I N G E X A E M P L A S O R T I N G E A X E M P L A S O R T I N G A E X E M P L A S O R T I N A G E X E M P L 59 Bubble Sort - Exemplo de Aplicação (Ciclo interior) A S O R T I N G E X A M P E L A S O R T I N G E X A M E P L A S O R T I N G E X A E M P L A S O R T I N G E X A E M P L A S O R T I N G E A X E M P L A S O R T I N G A E X E M P L A S O R T I N A G E X E M P L A S O R T I A N G E X E M P L 60 30

31 Bubble Sort - Exemplo de Aplicação (Ciclo interior) A S O R T I N G E X A M P E L A S O R T I N G E X A M E P L A S O R T I N G E X A E M P L A S O R T I N G E X A E M P L A S O R T I N G E A X E M P L A S O R T I N G A E X E M P L A S O R T I N A G E X E M P L A S O R T I A N G E X E M P L A S O R T A I N G E X E M P L 61 Bubble Sort - Exemplo de Aplicação (Ciclo interior) A S O R T I N G E X A M P E L A S O R T I N G E X A M E P L A S O R T I N G E X A E M P L A S O R T I N G E X A E M P L A S O R T I N G E A X E M P L A S O R T I N G A E X E M P L A S O R T I N A G E X E M P L A S O R T I A N G E X E M P L A S O R T A I N G E X E M P L A S O R A T I N G E X E M P L 62 31

32 Bubble Sort - Exemplo de Aplicação (Ciclo interior) A S O R T I N G E X A M P E L A S O R T I N G E X A M E P L A S O R T I N G E X A E M P L A S O R T I N G E X A E M P L A S O R T I N G E A X E M P L A S O R T I N G A E X E M P L A S O R T I N A G E X E M P L A S O R T I A N G E X E M P L A S O R T A I N G E X E M P L A S O R A T I N G E X E M P L A S O A R T I N G E X E M P L 63 Bubble Sort - Exemplo de Aplicação (Ciclo interior) A S O R T I N G E X A M P E L A S O R T I N G E X A M E P L A S O R T I N G E X A E M P L A S O R T I N G E X A E M P L A S O R T I N G E A X E M P L A S O R T I N G A E X E M P L A S O R T I N A G E X E M P L A S O R T I A N G E X E M P L A S O R T A I N G E X E M P L A S O R A T I N G E X E M P L A S O A R T I N G E X E M P L A S A O R T I N G E X E M P L 64 32

33 Bubble Sort - Exemplo de Aplicação (Ciclo interior) A S O R T I N G E X A M P E L A S O R T I N G E X A M E P L A S O R T I N G E X A E M P L A S O R T I N G E X A E M P L A S O R T I N G E A X E M P L A S O R T I N G A E X E M P L A S O R T I N A G E X E M P L A S O R T I A N G E X E M P L A S O R T A I N G E X E M P L A S O R A T I N G E X E M P L A S O A R T I N G E X E M P L A S A O R T I N G E X E M P L A A S O R T I N G E X E M P L 65 Bubble Sort - Exemplo de Aplicação (Ciclo interior) A S O R T I N G E X A M P E L A S O R T I N G E X A M E P L A S O R T I N G E X A E M P L A S O R T I N G E X A E M P L A S O R T I N G E A X E M P L A S O R T I N G A E X E M P L A S O R T I N A G E X E M P L A S O R T I A N G E X E M P L A S O R T A I N G E X E M P L A S O R A T I N G E X E M P L A S O A R T I N G E X E M P L A S A O R T I N G E X E M P L A A S O R T I N G E X E M P L A A S O R T I N G E X E M P L 66 33

34 Bubble Sort - Exemplo de Aplicação (Ciclo exterior) A A S O R T I N G E X E M P L 67 Bubble Sort - Exemplo de Aplicação (Ciclo exterior) A A S O R T I N G E X E M P L A A E S O R T I N G E X L M P 68 34

35 Bubble Sort - Exemplo de Aplicação (Ciclo exterior) A A S O R T I N G E X E M P L A A E S O R T I N G E X L M P A A E E S O R T I N G L X M P 69 Bubble Sort - Exemplo de Aplicação (Ciclo exterior) A A S O R T I N G E X E M P L A A E S O R T I N G E X L M P A A E E S O R T I N G L X M P A A E E G S O R T I N L M X P 70 35

36 Bubble Sort - Exemplo de Aplicação (Ciclo exterior) A A S O R T I N G E X E M P L A A E S O R T I N G E X L M P A A E E S O R T I N G L X M P A A E E G S O R T I N L M X P A A E E G I S O R T L N M P X 71 Bubble Sort - Exemplo de Aplicação (Ciclo exterior) A A S O R T I N G E X E M P L A A E S O R T I N G E X L M P A A E E S O R T I N G L X M P A A E E G S O R T I N L M X P A A E E G I S O R T L N M P X A A E E G I L S O R T M N P X 72 36

37 Bubble Sort - Exemplo de Aplicação (Ciclo exterior) A A S O R T I N G E X E M P L A A E S O R T I N G E X L M P A A E E S O R T I N G L X M P A A E E G S O R T I N L M X P A A E E G I S O R T L N M P X A A E E G I L S O R T M N P X A A E E G I L M S O R T N P X 73 Bubble Sort - Exemplo de Aplicação (Ciclo exterior) A A S O R T I N G E X E M P L A A E S O R T I N G E X L M P A A E E S O R T I N G L X M P A A E E G S O R T I N L M X P A A E E G I S O R T L N M P X A A E E G I L S O R T M N P X A A E E G I L M S O R T N P X A A E E G I L M N S O R T P X 74 37

38 Bubble Sort - Exemplo de Aplicação (Ciclo exterior) A A S O R T I N G E X E M P L A A E S O R T I N G E X L M P A A E E S O R T I N G L X M P A A E E G S O R T I N L M X P A A E E G I S O R T L N M P X A A E E G I L S O R T M N P X A A E E G I L M S O R T N P X A A E E G I L M N S O R T P X A A E E G I L M N O S P R T X 75 Bubble Sort - Exemplo de Aplicação (Ciclo exterior) A A S O R T I N G E X E M P L A A E S O R T I N G E X L M P A A E E S O R T I N G L X M P A A E E G S O R T I N L M X P A A E E G I S O R T L N M P X A A E E G I L S O R T M N P X A A E E G I L M S O R T N P X A A E E G I L M N S O R T P X A A E E G I L M N O S P R T X A A E E G I L M N O P S R T X 76 38

39 Bubble Sort - Exemplo de Aplicação (Ciclo exterior) A A S O R T I N G E X E M P L A A E S O R T I N G E X L M P A A E E S O R T I N G L X M P A A E E G S O R T I N L M X P A A E E G I S O R T L N M P X A A E E G I L S O R T M N P X A A E E G I L M S O R T N P X A A E E G I L M N S O R T P X A A E E G I L M N O S P R T X A A E E G I L M N O P S R T X A A E E G I L M N O P R S T X 77 Bubble Sort - Exemplo de Aplicação (Ciclo exterior) A A S O R T I N G E X E M P L A A E S O R T I N G E X L M P A A E E S O R T I N G L X M P A A E E G S O R T I N L M X P A A E E G I S O R T L N M P X A A E E G I L S O R T M N P X A A E E G I L M S O R T N P X A A E E G I L M N S O R T P X A A E E G I L M N O S P R T X A A E E G I L M N O P S R T X A A E E G I L M N O P R S T X A A E E G I L M N O P R S T X 78 39

40 Bubble Sort - Exemplo de Aplicação (Ciclo exterior) A A S O R T I N G E X E M P L A A E S O R T I N G E X L M P A A E E S O R T I N G L X M P A A E E G S O R T I N L M X P A A E E G I S O R T L N M P X A A E E G I L S O R T M N P X A A E E G I L M S O R T N P X A A E E G I L M N S O R T P X A A E E G I L M N O S P R T X A A E E G I L M N O P S R T X A A E E G I L M N O P R S T X A A E E G I L M N O P R S T X A A E E G I L M N O P R S T X 79 Bubble Sort - Exemplo de Aplicação (Ciclo exterior) A A S O R T I N G E X E M P L A A E S O R T I N G E X L M P A A E E S O R T I N G L X M P A A E E G S O R T I N L M X P A A E E G I S O R T L N M P X A A E E G I L S O R T M N P X A A E E G I L M S O R T N P X A A E E G I L M N S O R T P X A A E E G I L M N O S P R T X A A E E G I L M N O P S R T X A A E E G I L M N O P R S T X A A E E G I L M N O P R S T X A A E E G I L M N O P R S T X A A E E G I L M N O P R S T X 80 40

41 Bubble Sort - Exemplo de Aplicação (Ciclo exterior) A A S O R T I N G E X E M P L A A E S O R T I N G E X L M P A A E E S O R T I N G L X M P A A E E G S O R T I N L M X P A A E E G I S O R T L N M P X A A E E G I L S O R T M N P X A A E E G I L M S O R T N P X A A E E G I L M N S O R T P X A A E E G I L M N O S P R T X A A E E G I L M N O P S R T X A A E E G I L M N O P R S T X A A E E G I L M N O P R S T X A A E E G I L M N O P R S T X A A E E G I L M N O P R S T X A A E E G I L M N O P R S T X 81 Bubble Sort - Comentários [1] Movendo da direita para a esquerda no ficheiro de dados quando o elemento mais pequeno é encontrado na primeira passagem é sucessivamente trocado com todos à sua esquerda acaba por ficar na primeira posição na segunda passagem o 2 o elemento mais pequeno é colocado na sua posição e por diante N passagens pelos dados são suficientes! É semelhante ao método de selecção tem mais trabalho para colocar cada elemento na sua posição final todas as trocas sucessivas até chegar à posição certa 82 41

42 Bubble Sort - Comentários [2] Algoritmo pode ser melhorado, tal como o algoritmo de inserção código é muito semelhantes mas não igual ciclo interno de Insertion Sort percorre a parte esquerda(ordenada) da tabela ciclo interno de Bubble Sort percorre a parte direita(não ordenada) da tabela no final de cada passagem podemos testar se houve mudanças 83 Bubble Sort - Análise Propriedade Bubble sort usa aproximadamente N 2 /2 comparações e N 2 /2 trocas no caso médio e no pior caso Demonstração A i-ésima passagem de Bubble Sort requer N-i operações de comparação/troca, logo a demonstração é semelhante a Selection sort Factos Algoritmo pode depender criticamente dos dados se for modificado para terminar quando não houver mais trocas se o ficheiro estiver ordenado, apenas um passo é necessário se estiver em ordenação inversa então na i-ésima passagem são precisas N-1 comparações e trocas caso médio é semelhante (análise mais complexa) 84 42

43 Comparação dos algoritmos elementares de ordenação [1] Tempos de execução quadráticos Selection Insertion Bubble Comparações N 2 /2 N 2 /4 N 2 /2 Trocas N N 2 /4 N 2 /2 85 Comparação dos algoritmos elementares de ordenação [2] Ficheiros com elementos grandes e pequenas chaves Selection Sort é linear no número de dados N dados com tamanho M (palavras/words) comparação - 1 unidade; troca - M unidades N 2 /2 comparações e NM custo de trocas termo NM domina custo proporcional ao tempo necessário para mover os dados Ficheiros quase ordenados Insertion sort e Bubble sort são quase lineares os melhores algoritmos de ordenação podem ser quadráticos neste caso! 86 43

44 Comparação dos algoritmos elementares de ordenação [3] 87 Ordenação Síntese da Aula 1 Introdução ao problema da ordenação de dados Definição das regras base e interface de utilização Macros e operações elementares relevantes Ordenação por Selecção Select sort Descrição, exemplo de aplicação e análise de eficiência Ordenação por inserção Insertion sort Versão elementar e versão adaptativa Exemplo de aplicação e análise de Eficiência Bubble sort Breve referência Descrição do algoritmo e análise de funcionamento Exemplo de aplicação e análise de eficiência Comparação dos três algoritmos elementares Em número de comparações e trocas Na evolução da tabela durante a execução exemplo gráfico 88 44

45 Shellsort - Melhorar a eficiência [1] Insertion sort é lento porque apenas envolve trocas entre items adjacentes Se o menor item está no final da tabela, serão precisos N passos para o colocar na posição correcta Talvez se pudesse acelerar o algoritmo permitindo trocas entre elementos que estão afastados Como? Que tal fazer trocas entre elementos que estejam a uma distância fixa (maior que uma posição) entre si? Shellsort 89 Shellsort - Melhorar a eficiência [2] Ideia rearranjar os dados de forma a que tenham a propriedade tal que olhando para cada h-ésimo elemento estão ordenados dados dizem-se h-ordenados é equivalente a h sequências ordenadas entreligadas (entrelaçadas) Usando valores de h grandes é possível mover elementos na tabela grandes distâncias, o que torna mais fácil h-ordenar mais tarde com valores mais baixos de h usando este procedimento para qualquer sequência de h's que termine em 1 produzir-se-á um ficheiro ordenado cada passo torna o próximo mais simples 90 45

46 Shellsort - Melhorar a eficiência [3] Outra forma de ver o algoritmo A tabela é dividida em partições, cada uma contendo os objectos de índice %h Exemplo para uma tabela de 15 posições e h=4 índices resto 0, i%4=0, são: 0, 4, 8, 12 índices resto 1, i%4=1, são: 1, 5, 9, 13 índices resto 2, i%4=2, são: 2, 6, 10, 14 índices resto 3, i%4=3, são: 3, 7, 11, 15 dentro de cada partição é feita uma ordenação por inserção Exemplo permite visualizar bem o algoritmo h-ordenação - Exemplo: h=4 i%4=0 0,4,8,

47 h-ordenação - Exemplo: h=4 A S O R E I N G T X A M P L E i%4=0 0,4,8,12 93 h-ordenação - Exemplo: h=4 A S O R E I N G T X A M P L E A S O R E I N G P X A M T L E i%4=0 0,4,8,

48 h-ordenação - Exemplo: h=4 A S O R E I N G T X A M P L E A S O R E I N G P X A M T L E i%4=0 0,4,8,12 A I O R E S N G P X A M T L E i%4=1 1,5,9,13 95 h-ordenação - Exemplo: h=4 A S O R E I N G T X A M P L E A S O R E I N G P X A M T L E i%4=0 0,4,8,12 A I O R E S N G P X A M T L E A I O R E S N G P X A M T L E i%4=1 1,5,9,

49 h-ordenação - Exemplo: h=4 A S O R E I N G T X A M P L E A S O R E I N G P X A M T L E i%4=0 0,4,8,12 A I O R E S N G P X A M T L E A I O R E S N G P X A M T L E A I O R E L N G P S A M T X E i%4=1 1,5,9,13 97 h-ordenação - Exemplo: h=4 A S O R E I N G T X A M P L E A S O R E I N G P X A M T L E i%4=0 0,4,8,12 A I O R E S N G P X A M T L E A I O R E S N G P X A M T L E A I O R E L N G P S A M T X E i%4=1 1,5,9,13 A I N R E L O G P S A M T X E i%4=2 2,6,10,

50 h-ordenação - Exemplo: h=4 A S O R E I N G T X A M P L E A S O R E I N G P X A M T L E i%4=0 0,4,8,12 A I O R E S N G P X A M T L E A I O R E S N G P X A M T L E A I O R E L N G P S A M T X E i%4=1 1,5,9,13 A I N R E L O G P S A M T X E A I A R E L N G P S O M T X E i%4=2 2,6,10,14 99 h-ordenação - Exemplo: h=4 A S O R E I N G T X A M P L E A S O R E I N G P X A M T L E i%4=0 0,4,8,12 A I O R E S N G P X A M T L E A I O R E S N G P X A M T L E A I O R E L N G P S A M T X E i%4=1 1,5,9,13 A I N R E L O G P S A M T X E A I A R E L N G P S O M T X E A I A R E L E G P S N M T X O i%4=2 2,6,10,

51 h-ordenação - Exemplo: h=4 A S O R E I N G T X A M P L E A S O R E I N G P X A M T L E i%4=0 0,4,8,12 A I O R E S N G P X A M T L E A I O R E S N G P X A M T L E A I O R E L N G P S A M T X E i%4=1 1,5,9,13 A I N R E L O G P S A M T X E A I A R E L N G P S O M T X E A I A R E L E G P S N M T X O A I A G E L E R P S N M T X O i%4=2 2,6,10,14 i%4=3 3,7, h-ordenação - Exemplo: h=4 A S O R E I N G T X A M P L E A S O R E I N G P X A M T L E i%4=0 0,4,8,12 A I O R E S N G P X A M T L E A I O R E S N G P X A M T L E A I O R E L N G P S A M T X E i%4=1 1,5,9,13 A I N R E L O G P S A M T X E A I A R E L N G P S O M T X E A I A R E L E G P S N M T X O A I A G E L E R P S N M T X O A I A G E L E M P S N R T X O i%4=2 2,6,10,14 i%4=3 3,7,

52 h-ordenação - Exemplo: h=4 A S O R E I N G T X A M P L E A S O R E I N G P X A M T L E i%4=0 0,4,8,12 A I O R E S N G P X A M T L E A I O R E S N G P X A M T L E A I O R E L N G P S A M T X E i%4=1 1,5,9,13 A I N R E L O G P S A M T X E A I A R E L N G P S O M T X E A I A R E L E G P S N M T X O A I A G E L E R P S N M T X O A I A G E L E M P S N R T X O i%4=2 2,6,10,14 i%4=3 3,7,11 A I A G E L E M P S N R T X O 103 Implementação de Shellsort [1] Possível fazer melhor: sub-ficheiros são independentes quando h-ordenamos os dados inserimos qualquer elemento entre os do seu (h) sub-ficheiro movendo elementos maiores para a direita basta usar código de insertion com incrementos/decrementos de h em vez de 1 implementação de Shellsort usa um passo de Insertion sort pelo ficheiro para cada incremento Tabela não fica completamente ordenada depois da 1 a ordenação das várias partições é necessário repetir com uma série de partições isto é, não basta escolher/usar um só h!

53 Shellsort - Exemplo de aplicação [1] As partições estão enterlaçadas A I O R T S N G E X A M P L E A I N R T S O G E X A M P L E A I N G T S O R E X A M P L E A I N G E S O R T X A M P L E A I N G E S O R T X A M P L E A I A G E S N R T X O M P L E A I A G E S N M T X O R P L E A I A G E S N M P X O R T L E A I A G E L N M P S O R T X E A I A G E L E M P S N R T X O 105 Implementação de Shellsort [2] Solução óbvia para cada valor de h usar Insertion Sort de forma independente em cada um dos h sub-ficheiros int h = 4; for (i = l+h; i <= r; i++) { Item v = a[i]; j = i; while (j-h >= l && less(v, a[j-h])) { a[j] = a[j-h]; j -= h; } a[j] = v; } Então, teremos que definir uma sequência para os valores de h a utilizar

54 Sequência de Ordenação Difícil de escolher Propriedades de muitas sequências foram já estudadas Possível provar que umas são melhores que outras exemplo: 1, 4, 13, 40, 121, 364, 1093, 3280,... (Knuth, 3*h ant +1) melhor que 1, 2, 4, 8, 16, 32, 64, 128, 256, 512,... (Shell, 2 i ) Porquê? mas pior (20%) que 1, 8, 23, 77, 281, 1073, 4193, (4 i+1 + 3*2 i + 1) Na prática utilizam-se sequências que decrescem geometricamente para que o número de incrementos seja logarítmico A sequência óptima não foi ainda descoberta (se é que existe) Análise do algoritmo é desconhecida ninguém encontrou a fórmula que define a complexidade complexidade depende da sequência 107 Implementação de Shellsort [3] void shellsort(item a[], int l, int r) { int i, j, k; int incs[16] = { , , , 86961, 33936, 13776, 4592, 1968, 861, 336, 112, 48, 21, 7, 3, 1}; for ( k = 0; k < 16; k++) { int h = incs[k]; } } for (i = l+h; i <= r; i++) { Item v = a[i]; j = i; while (j-h >= l && less(v, a[j-h])) { exch(a[j], a[j-h]); /* a[j] = a[j-h]; */ j -= h; } a[j] = v; }

55 Shellsort - Exemplo de aplicação [2] h = 13 A E O R T I N G E X A M P L S h = 4 A E O R T I N G E X A M P L S A E O R T I N G E X A M P L S A E N R T I O G E X A M P L S A E N G T I O R E X A M P L S A E N G E I O R T X A M P L S A E N G E I O R T X A M P L S A E A G E I N R T X O M P L S A E A G E I N M T X O R P L S A E A G E I N M P X O R T L S A E A G E I N M P L O R T X S A E A G E I N M P L O R T X S h = 1 A E A G E I N M P L O R T X S A A E G E I N M P L O R T X S A A E G E I N M P L O R T X S A A E E G I N M P L O R T X S A A E E G I N M P L O R T X S A A E E G I N M P L O R T X S A A E E G I M N P L O R T X S A A E E G I M N P L O R T X S A A E E G I L M N P O R T X S A A E E G I L M N O P R T X S A A E E G I L M N O P R T X S A A E E G I L M N O P R T X S A A E E G I L M N O P R T X S A A E E G I L M N O P R S T X A A E E G I L M N O P R S T X 109 Análise de Shellsort Propriedades O resultado de h-ordenar um ficheiro que está k-ordenado é um ficheiro que está simultaneamente h- e k-ordenado Shellsort faz menos do que O(N 3/2 ) comparações para os incrementos 1, 4, 13, 40, 121, 364, 1093,... Shellsort faz menos do que O(N 4/3 ) comparações para os incrementos 1, 8, 23, 77, 281, 1073, 4193, 16577,... Nota: sequências até agora usam incrementos que são primos entre si Shellsort faz menos do que O(Nlog 2 N) comparações para os incrementos 1, 2, 3, 4, 6, 9, 8, 12, 18, 27, 16, 24, 36, 54, 81 Shellsort é um exemplo de um algoritmo simples cuja análise é complicada sequência óptima, e análise completa não são conhecidos! Alguém consegue encontrar uma sequência que bata1, 2, 7, 21, 48, 112, 336,...??

56 Shellsort - Exemplo Gráfico e Vantagens Graficamente parece que um elástico, preso nos cantos, puxa os pontos para a diagonal Vantagens do Shellsort Rápido/eficiente Pouco código Melhor método para ficheiros pequenos e médios Aceitável para elevados volumes de dados Muito utilizado na prática, embora dificil de compreender! 111 Ordenação de outros tipos de dados [1] Algoritmos estudados são independentes do tipo de dados necessário o interface apropriado e a implementação correspondente #include <stdlib.h> #define N_ELEMS main () { int sw, N = N_ELEMS; int a[n_elems]; } if (sw) randinit(a, N); else scaninit(a, &N); sort (a, 0, N-1); show (a, 0, N-1); for (i = 0; i < N; i++) a[i] = 1000 * (1.0*rand()/RAND_MAX); while (scanf( %d, &a[n]) == 1) N++; for (i = 0; i < N; i++) printf( %3d, a[i]); printf( \n );

57 Ordenação de outros tipos de dados [1] Algoritmos estudados são independentes do tipo de dados necessário o interface apropriado e a implementação correspondente #include <stdlib.h> main (int argc, char *argv[]) { int N = atoi (argv[1]), sw = atoi (argv[2]); int *a = malloc (N * sizeof(int)); } if (sw) randinit(a, N); else scaninit(a, &N); sort (a, 0, N-1); show (a, 0, N-1); for (i = 0; i < N; i++) a[i] = 1000 * (1.0*rand()/RAND_MAX); while (scanf( %d, &a[n]) == 1) N++; for (i = 0; i < N; i++) printf( %3d, a[i]); printf( \n ); 113 Ordenação de outros tipos de dados [2] Algoritmos estudados são independentes do tipo de dados necessário o interface apropriado e a implementação correspondente #include <stdlib.h> #include Item.h #include Array.h #define N_ELEMS main (int argc, char *argv[]) { int sw, N = N_ELEMS; Item a[n_elems]: } if (sw) randinit(a, N); else scaninit(a, &N); sort (a, 0, N-1); show (a, 0, N-1);

58 Ordenação de outros tipos de dados [2] Algoritmos estudados são independentes do tipo de dados necessário o interface apropriado e a implementação correspondente #include <stdlib.h> #include Item.h #include Array.h main (int argc, char *argv[]) { int N = atoi (argv[1]), sw = atoi (argv[2]); Item *a = malloc (N * sizeof(item)); } if (sw) randinit(a, N); else scaninit(a, &N); sort (a, 0, N-1); show (a, 0, N-1); 115 Ordenação de outros tipos de dados [3] Definição do interface O tipo apropriado e as funções para sua manipulação typedef double Item; #define key(a) (A) #define less(a, B) (key(a) < key(b)) #define exch(a, B) {Item t = A; A = B; B = t; } #define compexch(a, B) if (less(b,a)) exch(a, B) Item ITEMrand(void); int ITEMscan(Item *); void ITEMshow(Item); Interface para tipo Item Item.h void randinit (Item [], int); void scaninit (Item [], int *); void show (Item [], int, int); void sort (Item [], int, int); Interface para tipo tabela de Items Array.h

59 Ordenação de outros tipos de dados [4] Implementação do interface Implementação das funções que operam sobre os dados #include <stdio.h> #include <stdlib.h> #include Item.h double ITEMrand(void){ return 1.0 * rand() / RAND_MAX; } Implementação para tipo Item (double) int ITEMscan(double *x){ return scanf( %lf, x); } void ITEMshow(double x){ printf( %7.5lf, x); } 117 Ordenação de outros tipos de dados [5] Implementação do interface Implementação das funções que operam sobre os dados #include <stdio.h> #include <stdlib.h> #include Item.h #include Array.h Implementação para tipo tabela de Items void randinit(item a[], int N){ int i; for (i = 0; i < N; i++) a[i] = ITEMrand(); } void scaninit(item a[], int *N){ int i =0;; for (i = 0; i < *N; i++) if (ITEMscan(&a[i]) == EOF) break; *N = i; } void show(item a[], int l, int r){ int i; for (i = l; i <= r; i++) ITEMshow(a[i]); printf( \n ); }

60 Ordenação de outros tipos de dados [6] Para qualquer tipo de dados Apenas alterar o interface Reescrever as funções que operam sobre os objectos rand show exch etc. Algoritmos e rotinas de ordenação (sorting) não necessitam de qualquer alteração 119 Ordenação por índices [1] Suponha-se que os objectos a ordenar são strings (vectores de caracteres): funções que operam sobre os dados precisam de ter em conta a questão da alocação de memória para strings quem deve ser responsável pela gestão desta memória? e se os objectos são "grandes"? Comparar e mover os objectos pode ser dispendioso! imagine que cada objecto é o nome completo de um aluno (ou que é toda a sua informação: nome, morada, etc) mesmo que haja uma boa abstracção para operar sobre os objectos ainda há a questão do custo Porquê movê-los? porque não alterar apenas referência para a sua posição relativa?

61 Ordenação por índices [2] Solução 1: dados numa tabela data[0],..., data[n-1] usar uma segunda tabela, a[.], apenas de índices inicializado de forma a que a[i] = i, i = 0,..., N-1 objectivo é rearranjar a tabela de índices de forma a que a[0] aponte para o objecto com a menor chave, etc objectos são apenas acedidos para comparação Rotinas de ordenação apenas acedem aos dados através de funções de interface: less, exch, etc apenas estas têm de ser reescritas 121 Ordenação por índices - Exemplo Suponha os seguintes dados: data = [ rui, carlos, luis ] usamos uma tabela, de índices a = [0, 1, 2] 1 o passo: comparar data[a[1]] com data[a[0]]: carlos < rui pelo que há troca de a[1] com a[0]: a = [ 1, 0, 2 ] 2 o passo: comparar data[a[2]] com data[a[1]]: rui < luis pelo que há troca de a[2] com a[1]: a = [ 1, 2, 0 ] 3 o passo: comparar data[a[1]] com data[a[0]]: carlos < luis pelo que não há troca Os valores ordenados são portanto data[a[0]], data[a[1]] e data[a[2]] ou seja, carlos < luis < rui (de forma encapotada usámos uma espécie de Insertion sort)

62 Ordenação por ponteiros Outra solução é a tabela de índices conter de facto ponteiros para os dados Mais geral pois os ponteiros podem apontar para qualquer lado items não precisam de ser membros de uma tabela nem de ter todos o mesmo tamanho Depois da ordenação, acesso sequencial à tabela de ponteiros devolve os elementos ordenados Um exemplo é a função qsort, do C, que implementa o algoritmo quicksort (estudaremos adiante) void qsort(void *array, size_t nitems, size_t sizeitem, int(*compar)(const void *, const void *)); 123 Ordenação por ponteiros ou índices Não-intrusiva em relação aos dados pode ser efectuada se os dados forem apenas de leitura Possível efectuar ordenação em chaves múltiplas exemplo: listagens de alunos, com nome, número e nota Evita o custo de mover/trocar os items pode ser elevado se estes forem grandes quantidades de informação mais eficiente em problemas com dados grandes e chaves pequenas E se for preciso retornar os dados ordenados? ordenar por índice/ponteiro fazer permutações in-situ (como?)

63 Ordenação de listas ligadas Semelhante a ordenação de tabelas funções de interface diferentes necessário trabalhar com ponteiros e não apenas com índices Trocas podem não ser possíveis elementos podem ser acedidos por outras estruturas de dados trocam-se apenas os ponteiros inserções são na verdade mais simples não é preciso mover elementos para a direita, apenas ajustar dois ponteiros Algoritmos básicos alterações simples 125 Exercício - usar Selection Sort para ordenar uma lista ligada Estruturas de Dados: lista de entrada lista de saída: dados colocados na sua posição final ponteiros adicionais Ideia básica procurar maior elemento na lista manter ponteiro para o anterior retirá-lo da lista de entrada introduzi-lo no início da lista de saída Implemente como exemplo!

64 Ordenação Síntese da Aula 2 Shellsort Variante de aceleração do Insertion sort Descrição e implementação: sequências de ordenação Exemplo de aplicação e discussão da eficiência do algoritmo Exemplo de execução e análise comparativa Ordenação de outros tipos de dados Implementações estudadas até aqui assumiam ordenação de inteiros Definição da interface apropriada Protótipos de funções elementares e definição dos dados Para evitar mover grandes quantidades de dados Ordenação por índices Ordenação por ponteiros Ordenação em listas ligadas Referência às alterações a introduzir nos algoritmos analisados Ao nível dos dados de entrada Ao nível da interface