porquê estudar algoritmos elementares - técnico … e estruturas de dados - c 4 nomenclatura [3] 7...
Post on 09-Nov-2018
219 Views
Preview:
TRANSCRIPT
Algoritmos e Estruturas de Dados - C
1
Algoritmos e Estruturas de Dados LEE – 2014/2015
Algoritmos de Ordenação – Parte I
Porquê estudar algoritmos elementares (de ordenação)
AED (IST/DEEC) 2
} 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"
Algoritmos e Estruturas de Dados - C
2
Contexto e regras básicas [1]
AED (IST/DEEC) 3
} 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
Contexto e regras básicas [2]
AED (IST/DEEC) 4
} 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
} Tempo de execução usualmente proporcional ao número de comparações número de movimentações/trocas (ou ambos)
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)
Algoritmos e Estruturas de Dados - C
3
Nomenclatura [1]
AED (IST/DEEC) 5
} 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: N2 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
Nomenclatura [2]
AED (IST/DEEC) 6
} 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
Algoritmos e Estruturas de Dados - C
4
Nomenclatura [3]
AED (IST/DEEC) 7
} 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
Nomenclatura [4]
AED (IST/DEEC) 8
} 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
Algoritmos e Estruturas de Dados - C
5
Contexto de utilização XXX
AED (IST/DEEC) 9
} Mesmo programa, diferentes drivers para diferentes algoritmos
} Para cada algoritmo, “sort” tem nome apropriado
#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”); }
Contexto de utilização
AED (IST/DEEC) 10
} Mesmo programa, diferentes drivers para diferentes algoritmos
} Para cada algoritmo, “sort” tem nome apropriado
#include <stdio.h> #include <stdlib.h> #define N_ELEMS 100000 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”); }
Algoritmos e Estruturas de Dados - C
6
Ordenação por selecção - Selection Sort
AED (IST/DEEC) 11
} Um dos mais simples } Algoritmo
} procurar menor elemento e trocar com o elemento na 1a posição } procurar 2o menor elemento e trocar com o elemento na 2a 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
...
Selection Sort - Exemplo de Aplicação
AED (IST/DEEC) 12
A S O R T I N G E X A M P L E
Algoritmos e Estruturas de Dados - C
7
Selection Sort - Exemplo de Aplicação
AED (IST/DEEC) 13
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
Selection Sort - Exemplo de Aplicação
AED (IST/DEEC) 14
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
A A O R T I N G E X S M P L E
Algoritmos e Estruturas de Dados - C
8
Selection Sort - Exemplo de Aplicação
AED (IST/DEEC) 15
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Selection Sort - Exemplo de Aplicação
AED (IST/DEEC) 16
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
9
Selection Sort - Exemplo de Aplicação
AED (IST/DEEC) 17
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Selection Sort - Exemplo de Aplicação
AED (IST/DEEC) 18
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
10
Selection Sort - Exemplo de Aplicação
AED (IST/DEEC) 19
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Selection Sort - Exemplo de Aplicação
AED (IST/DEEC) 20
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
11
Selection Sort - Exemplo de Aplicação
AED (IST/DEEC) 21
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Selection Sort - Exemplo de Aplicação
AED (IST/DEEC) 22
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
12
Selection Sort - Exemplo de Aplicação
AED (IST/DEEC) 23
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Selection Sort - Exemplo de Aplicação
AED (IST/DEEC) 24
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
13
Selection Sort - Exemplo de Aplicação
AED (IST/DEEC) 25
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Selection Sort - Exemplo de Aplicação
AED (IST/DEEC) 26
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
14
Selection Sort - Exemplo de Aplicação
AED (IST/DEEC) 27
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Selection Sort - Exemplo de Aplicação
AED (IST/DEEC) 28
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
15
Selection Sort - Análise
AED (IST/DEEC) 29
} 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 N2/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)+...+2+1=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)
Ordenação por inserção - Insertion Sort
AED (IST/DEEC) 30
} 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 1a 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; for (i = l+1; i <= r; i++) for (j = i; j > l; j--) compexch (a[j-1], a[j]); }
Ciclo exterior
Ciclo interior
...
Algoritmos e Estruturas de Dados - C
16
Insertion Sort - Comentários
AED (IST/DEEC) 31
} 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
Insertion Sort - Melhorar desempenho
AED (IST/DEEC) 32
} 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
Algoritmos e Estruturas de Dados - C
17
Insertion Sort - Versão adaptativa
AED (IST/DEEC) 33
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; } }
Insertion Sort - Exemplo de Aplicação
AED (IST/DEEC) 34
A S O R T I N G E X A M P L E
Algoritmos e Estruturas de Dados - C
18
Insertion Sort - Exemplo de Aplicação
AED (IST/DEEC) 35
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
Insertion Sort - Exemplo de Aplicação
AED (IST/DEEC) 36
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
A O S R T I N G E X A M P L E
Algoritmos e Estruturas de Dados - C
19
Insertion Sort - Exemplo de Aplicação
AED (IST/DEEC) 37
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Insertion Sort - Exemplo de Aplicação
AED (IST/DEEC) 38
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
20
Insertion Sort - Exemplo de Aplicação
AED (IST/DEEC) 39
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Insertion Sort - Exemplo de Aplicação
AED (IST/DEEC) 40
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
21
Insertion Sort - Exemplo de Aplicação
AED (IST/DEEC) 41
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Insertion Sort - Exemplo de Aplicação
AED (IST/DEEC) 42
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
22
Insertion Sort - Exemplo de Aplicação
AED (IST/DEEC) 43
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Insertion Sort - Exemplo de Aplicação
AED (IST/DEEC) 44
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
23
Insertion Sort - Exemplo de Aplicação
AED (IST/DEEC) 45
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Insertion Sort - Exemplo de Aplicação
AED (IST/DEEC) 46
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
24
Insertion Sort - Exemplo de Aplicação
AED (IST/DEEC) 47
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Insertion Sort - Exemplo de Aplicação
AED (IST/DEEC) 48
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
25
Insertion Sort - Exemplo de Aplicação
AED (IST/DEEC) 49
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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
Insertion Sort - Análise
AED (IST/DEEC) 50
} Propriedade – Insertion sort usa aproximadamente N2/4 comparações e N2/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...)
Algoritmos e Estruturas de Dados - C
26
Bubble Sort
AED (IST/DEEC) 51
} 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
...
Bubble Sort - Exemplo de Aplicação (Ciclo interior)
AED (IST/DEEC) 52
A S O R T I N G E X A M P L E
Algoritmos e Estruturas de Dados - C
27
Bubble Sort - Exemplo de Aplicação (Ciclo interior)
AED (IST/DEEC) 53
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P E L
Bubble Sort - Exemplo de Aplicação (Ciclo interior)
AED (IST/DEEC) 54
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
28
Bubble Sort - Exemplo de Aplicação (Ciclo interior)
AED (IST/DEEC) 55
A S O R T I N G E X A M P L E
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
Bubble Sort - Exemplo de Aplicação (Ciclo interior)
AED (IST/DEEC) 56
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
29
Bubble Sort - Exemplo de Aplicação (Ciclo interior)
AED (IST/DEEC) 57
A S O R T I N G E X A M P L E
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
Bubble Sort - Exemplo de Aplicação (Ciclo interior)
AED (IST/DEEC) 58
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
30
Bubble Sort - Exemplo de Aplicação (Ciclo interior)
AED (IST/DEEC) 59
A S O R T I N G E X A M P L E
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
Bubble Sort - Exemplo de Aplicação (Ciclo interior)
AED (IST/DEEC) 60
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
31
Bubble Sort - Exemplo de Aplicação (Ciclo interior)
AED (IST/DEEC) 61
A S O R T I N G E X A M P L E
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
Bubble Sort - Exemplo de Aplicação (Ciclo interior)
AED (IST/DEEC) 62
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
32
Bubble Sort - Exemplo de Aplicação (Ciclo interior)
AED (IST/DEEC) 63
A S O R T I N G E X A M P L E
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
Bubble Sort - Exemplo de Aplicação (Ciclo interior)
AED (IST/DEEC) 64
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
33
Bubble Sort - Exemplo de Aplicação (Ciclo interior)
AED (IST/DEEC) 65
A S O R T I N G E X A M P L E
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
Bubble Sort - Exemplo de Aplicação (Ciclo interior)
AED (IST/DEEC) 66
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
34
Bubble Sort - Exemplo de Aplicação (Ciclo exterior)
AED (IST/DEEC) 67
A S O R T I N G E X A M P L E
A A S O R T I N G E X E M P L
Bubble Sort - Exemplo de Aplicação (Ciclo exterior)
AED (IST/DEEC) 68
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
35
Bubble Sort - Exemplo de Aplicação (Ciclo exterior)
AED (IST/DEEC) 69
A S O R T I N G E X A M P L E
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
Bubble Sort - Exemplo de Aplicação (Ciclo exterior)
AED (IST/DEEC) 70
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
36
Bubble Sort - Exemplo de Aplicação (Ciclo exterior)
AED (IST/DEEC) 71
A S O R T I N G E X A M P L E
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
Bubble Sort - Exemplo de Aplicação (Ciclo exterior)
AED (IST/DEEC) 72
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
37
Bubble Sort - Exemplo de Aplicação (Ciclo exterior)
AED (IST/DEEC) 73
A S O R T I N G E X A M P L E
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
Bubble Sort - Exemplo de Aplicação (Ciclo exterior)
AED (IST/DEEC) 74
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
38
Bubble Sort - Exemplo de Aplicação (Ciclo exterior)
AED (IST/DEEC) 75
A S O R T I N G E X A M P L E
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
Bubble Sort - Exemplo de Aplicação (Ciclo exterior)
AED (IST/DEEC) 76
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
39
Bubble Sort - Exemplo de Aplicação (Ciclo exterior)
AED (IST/DEEC) 77
A S O R T I N G E X A M P L E
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
Bubble Sort - Exemplo de Aplicação (Ciclo exterior)
AED (IST/DEEC) 78
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
40
Bubble Sort - Exemplo de Aplicação (Ciclo exterior)
AED (IST/DEEC) 79
A S O R T I N G E X A M P L E
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
Bubble Sort - Exemplo de Aplicação (Ciclo exterior)
AED (IST/DEEC) 80
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
41
Bubble Sort - Exemplo de Aplicação (Ciclo exterior)
AED (IST/DEEC) 81
A S O R T I N G E X A M P L E
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
Bubble Sort - Comentários [1]
AED (IST/DEEC) 82
} 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 2o 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
Algoritmos e Estruturas de Dados - C
42
Bubble Sort - Comentários [2]
AED (IST/DEEC) 83
} 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
Bubble Sort - Análise
AED (IST/DEEC) 84
} Propriedade – Bubble sort usa aproximadamente N2/2 comparações e N2/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)
Algoritmos e Estruturas de Dados - C
43
Comparação dos algoritmos elementares de ordenação [1]
AED (IST/DEEC) 85
} Tempos de execução quadráticos
Selection Insertion Bubble
Comparações N2/2 N2/4 N2/2
Trocas N N2/4 N2/2
Comparação dos algoritmos elementares de ordenação [2]
AED (IST/DEEC) 86
} 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
} N2/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!
Algoritmos e Estruturas de Dados - C
44
Comparação dos algoritmos elementares de ordenação [3]
AED (IST/DEEC) 87
Ordenação – Síntese da Aula 1
AED (IST/DEEC) 88
} 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
Algoritmos e Estruturas de Dados - C
45
Shellsort - Melhorar a eficiência [1]
AED (IST/DEEC) 89
} 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
Shellsort - Melhorar a eficiência [2]
AED (IST/DEEC) 90
} 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
Algoritmos e Estruturas de Dados - C
46
Shellsort - Melhorar a eficiência [3]
AED (IST/DEEC) 91
} 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
AED (IST/DEEC) 92
A S O R T I N G E X A M P L E i%4=0 0,4,8,12
Algoritmos e Estruturas de Dados - C
47
h-Ordenação - Exemplo: h=4
AED (IST/DEEC) 93
A S O R T I N G E X A M P L E
A S O R E I N G T X A M P L E i%4=0 0,4,8,12
h-Ordenação - Exemplo: h=4
AED (IST/DEEC) 94
A S O R T I N G E X A M P L E
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
Algoritmos e Estruturas de Dados - C
48
h-Ordenação - Exemplo: h=4
AED (IST/DEEC) 95
A S O R T I N G E X A M P L E
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
A I O R E S N G P X A M T L E
i%4=0 0,4,8,12
i%4=1 1,5,9,13
h-Ordenação - Exemplo: h=4
AED (IST/DEEC) 96
A S O R T I N G E X A M P L E
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
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=0 0,4,8,12
i%4=1 1,5,9,13
Algoritmos e Estruturas de Dados - C
49
h-Ordenação - Exemplo: h=4
AED (IST/DEEC) 97
A S O R T I N G E X A M P L E
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
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=0 0,4,8,12
i%4=1 1,5,9,13
h-Ordenação - Exemplo: h=4
AED (IST/DEEC) 98
A S O R T I N G E X A M P L E
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
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
A I N R E L O G P S A M T X E
i%4=0 0,4,8,12
i%4=1 1,5,9,13
i%4=2 2,6,10,14
Algoritmos e Estruturas de Dados - C
50
h-Ordenação - Exemplo: h=4
AED (IST/DEEC) 99
A S O R T I N G E X A M P L E
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
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
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=0 0,4,8,12
i%4=1 1,5,9,13
i%4=2 2,6,10,14
h-Ordenação - Exemplo: h=4
AED (IST/DEEC) 100
A S O R T I N G E X A M P L E
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
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
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=0 0,4,8,12
i%4=1 1,5,9,13
i%4=2 2,6,10,14
Algoritmos e Estruturas de Dados - C
51
h-Ordenação - Exemplo: h=4
AED (IST/DEEC) 101
A S O R T I N G E X A M P L E
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
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
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=0 0,4,8,12
i%4=1 1,5,9,13
i%4=2 2,6,10,14
i%4=3 3,7,11
h-Ordenação - Exemplo: h=4
AED (IST/DEEC) 102
A S O R T I N G E X A M P L E
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
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
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=0 0,4,8,12
i%4=1 1,5,9,13
i%4=2 2,6,10,14
i%4=3 3,7,11
Algoritmos e Estruturas de Dados - C
52
h-Ordenação - Exemplo: h=4
AED (IST/DEEC) 103
A S O R T I N G E X A M P L E
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
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
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=0 0,4,8,12
i%4=1 1,5,9,13
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
Implementação de Shellsort [1]
AED (IST/DEEC) 104
} 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 1a 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!
Algoritmos e Estruturas de Dados - C
53
Shellsort - Exemplo de aplicação [1]
AED (IST/DEEC) 105
A S O R T I N G E X A M P L E
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
As partições estão enterlaçadas
Implementação de Shellsort [2]
AED (IST/DEEC) 106
} Solução óbvia – para cada valor de h usar Insertion Sort de forma independente em cada um dos h sub-ficheiros
} Então, teremos que definir uma sequência para os valores de h a utilizar
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; }
Algoritmos e Estruturas de Dados - C
54
Sequência de Ordenação
AED (IST/DEEC) 107
} 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*hant+1) melhor que 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, ... (Shell, 2i ) ¨ Porquê?
mas pior (20%) que 1, 8, 23, 77, 281, 1073, 4193, … (4i+1 + 3*2i + 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
Implementação de Shellsort [3]
AED (IST/DEEC) 108
void shellsort(Item a[], int l, int r) { int i, j, k; int incs[16] = {1391376, 463792, 198768, 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; } } }
Algoritmos e Estruturas de Dados - C
55
Shellsort - Exemplo de aplicação [2]
AED (IST/DEEC) 109
A S O R T I N G E X A M P L E
A S O R T I N G E X A M P L E
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 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
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
h = 13
h = 4
h = 1
Análise de Shellsort
AED (IST/DEEC) 110
} 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(N3/2) comparações para os incrementos 1, 4, 13,
40, 121, 364, 1093, ... } Shellsort faz menos do que O(N4/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(Nlog2N) 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, ...??
Algoritmos e Estruturas de Dados - C
56
Shellsort - Exemplo Gráfico e Vantagens
AED (IST/DEEC) 111
} 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!
Ordenação de outros tipos de dados [1]
AED (IST/DEEC) 112
} 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 100000 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”);
Algoritmos e Estruturas de Dados - C
57
Ordenação de outros tipos de dados [1]
AED (IST/DEEC) 113
} 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”);
Ordenação de outros tipos de dados [2]
AED (IST/DEEC) 114
} 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 100000 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); }
Algoritmos e Estruturas de Dados - C
58
Ordenação de outros tipos de dados [2]
AED (IST/DEEC) 115
} 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); }
Ordenação de outros tipos de dados [3]
AED (IST/DEEC) 116
} 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);
void randinit (Item [], int); void scaninit (Item [], int *); void show (Item [], int, int); void sort (Item [], int, int);
Interface para tipo Item
Interface para tipo tabela de Items
Item.h
Array.h
Algoritmos e Estruturas de Dados - C
59
Ordenação de outros tipos de dados [4]
AED (IST/DEEC) 117
} 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; } int ITEMscan(double *x){ return scanf(“%lf”, x); } void ITEMshow(double x){ printf(“%7.5lf “, x); }
Implementação para tipo Item (double)
Ordenação de outros tipos de dados [5]
AED (IST/DEEC) 118
} 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” 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”); }
Implementação para tipo tabela de Items
Algoritmos e Estruturas de Dados - C
60
Ordenação de outros tipos de dados [6]
AED (IST/DEEC) 119
} 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
Ordenação por índices [1]
AED (IST/DEEC) 120
} 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?
Algoritmos e Estruturas de Dados - C
61
Ordenação por índices [2]
AED (IST/DEEC) 121
} 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
Ordenação por índices - Exemplo
AED (IST/DEEC) 122
} Suponha os seguintes dados: } data = [“rui”, “carlos”, “luis”] } usamos uma tabela, de índices a = [0, 1, 2]
} 1o 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 ]
} 2o 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 ]
} 3o 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)
Algoritmos e Estruturas de Dados - C
62
Ordenação por ponteiros
AED (IST/DEEC) 123
} 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 *));
Ordenação por ponteiros ou índices
AED (IST/DEEC) 124
} 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?)
Algoritmos e Estruturas de Dados - C
63
Ordenação de listas ligadas
AED (IST/DEEC) 125
} 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
Exercício - usar Selection Sort para ordenar uma lista ligada
AED (IST/DEEC) 126
} 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!
Algoritmos e Estruturas de Dados - C
64
Ordenação – Síntese da Aula 2
AED (IST/DEEC) 127
} “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
top related