Algoritmos e Estrutura de Dados
|
|
|
- Airton da Silva Gameiro
- 8 Há anos
- Visualizações:
Transcrição
1 Algoritmos e Estrutura de Dados Ricardo Terra rterrabh [at] gmail.com Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
![CV Nome: Ricardo Terra Email: rterrabh [at] gmail.com www: ricardoterra.com.br Twitter: rterrabh Lattes: lattes.cnpq.br/ 0162081093970868 Ph.D.](/docs-images/67/57999066/images/2-0.jpg "(UFMG/UWaterloo), Post-Ph.D. (INRIA/Université Lille 1) Background Acadêmico : UFLA (desde 2014), UFSJ (1 ano ), FUMEC (3 anos ), UNIPAC (1 ano ), FAMINAS (3 anos ) Profissional : DBA Eng.")
2 CV Nome: Ricardo Terra rterrabh [at] gmail.com www: ricardoterra.com.br Twitter: rterrabh Lattes: lattes.cnpq.br/ Ph.D. (UFMG/UWaterloo), Post-Ph.D. (INRIA/Université Lille 1) Background Acadêmico : UFLA (desde 2014), UFSJ (1 ano ), FUMEC (3 anos ), UNIPAC (1 ano ), FAMINAS (3 anos ) Profissional : DBA Eng. (1 ano ), Synos (2 anos ), Stefanini (1 ano ) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
3 1. Introdução Conteúdo 1 Introdução 3 Conteúdo 4 2 Estrutura de Dados 6 3 Análise de Algoritmos 34 4 Métodos de Ordenação 71 5 Pesquisa em Memória Primária 108 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
4 Introdução Conteúdo Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
5 Introdução Conteúdo Com o domínio de C ANSI, este material tem como objetivo: Descrever as estruturas de dados básicas Lista Fila Pilha Introduzir à análise de complexidade de algoritmos Abordar os principais métodos de ordenação Apresentar o método de pesquisa binária Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
6 2. Estrutura de Dados Conteúdo 1 Introdução 3 2 Estrutura de Dados 6 Listas 7 Filas 17 Pilhas 25 3 Análise de Algoritmos 34 4 Métodos de Ordenação 71 5 Pesquisa em Memória Primária 108 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
7 Estrutura de Dados Listas Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
8 Estrutura de Dados Listas Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
9 Estrutura de Dados Listas Conceito (pense abstrato) 1 int main (int argc, char* argv[]){ 2 TLista* l; 3 l = inicializa(); 4 insere(l, D ); 5 insere(l, I ); 6 insere(l, O ); 7 insere(l, A ); 8 insere(l, L ); 9 insere(l, X ); 10 insere(l, O ); 11 printf("tamanho: %d\n", tamanho(l)); retira(l, D ); 14 retira(l, I ); 15 retira(l, X ); 16 retira(l, O ); 17 printf("tamanho: %d\n", tamanho(l)); retira(l, Z ); 20 printf("tamanho: %d\n", tamanho(l)); imprime(l); /* limpar(l); */ 25 printf("tamanho: %d\n", tamanho(l)); return 0; 28 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
10 Estrutura de Dados Listas Estruturas TCelula e TLista 1 #include<stdio.h> 2 #include<stdlib.h> 3 4 struct Celula { 5 char info; 6 struct Celula *prox; 7 }; typedef struct Celula TCelula; 11 typedef struct { 12 TCelula *primeiro; 13 TCelula *ultimo; 14 } TLista; Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
11 Estrutura de Dados Listas Função inicializa 15 TLista* inicializa(){ 16 TLista *l = (TLista*) malloc (sizeof(tlista)); 17 l->primeiro = (TCelula*) malloc (sizeof(tcelula)); 18 l->ultimo = l->primeiro; 19 l->primeiro->prox = NULL; 20 return l; 21 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
12 Estrutura de Dados Listas Função vazia 22 int vazia(tlista *l){ 23 return (l->primeiro == l->ultimo); 24 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
13 Estrutura de Dados Listas Função tamanho 25 int tamanho(tlista *l){ 26 TCelula* aux; 27 int tamanho = 0; 28 for(aux=l->primeiro->prox; aux!= NULL; aux = aux->prox){ 29 tamanho++; 30 } 31 return tamanho; 32 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
14 Estrutura de Dados Listas Função insere 33 void insere(tlista *l, char c){ 34 l->ultimo->prox = (TCelula*) malloc (sizeof(tcelula)); 35 l->ultimo = l->ultimo->prox; 36 l->ultimo->info = c; 37 l->ultimo->prox = NULL; 38 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
15 Estrutura de Dados Listas Função imprime 39 void imprime(tlista *l){ 40 TCelula* aux; 41 for(aux=l->primeiro->prox; aux!= NULL; aux = aux->prox){ 42 printf("info = %c\n", aux->info); 43 } 44 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
16 Estrutura de Dados Listas Função retira 45 int retira(tlista* l, char c){ 46 TCelula *aux, *rastro; if (!vazia(l)) { /* Se a lista nao for vazia */ 49 rastro = l->primeiro; 50 aux = l->primeiro->prox; for(; aux!= NULL ; aux = aux->prox, rastro = rastro->prox){ 53 if (aux->info == c){ 54 if (aux->prox == NULL){ /* Se for o ultimo */ 55 l->ultimo = rastro; 56 } 57 rastro->prox = aux->prox; 58 free(aux); 59 return 1; 60 } 61 } 62 } 63 return 0; 64 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
17 Estrutura de Dados Filas Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
18 Estrutura de Dados Filas Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
19 Estrutura de Dados Filas Conceito (pense abstrato) 1 int main (int argc, char* argv[]){ 2 TFila* f; 3 f = inicializa(); 4 printf("vazia: %s\n", (vazia(f))? "Sim" : "Nao"); 5 6 enfileira(f, A ); 7 printf("vazia: %s\n", (vazia(f))? "Sim" : "Nao"); 8 9 enfileira(f, B ); 10 enfileira(f, C ); printf("desenfileirou: %c\n", desenfileira(f)); 13 printf("desenfileirou: %c\n", desenfileira(f)); 14 printf("desenfileirou: %c\n", desenfileira(f)); if (!vazia(f)){ 17 printf("desenfileirou: %c\n", desenfileira(f)); 18 } enfileira(f, D ); 21 enfileira(f, E ); while (!vazia(f)){ 24 printf("desenfileirou: %c\n", desenfileira(f)); 25 } 26 printf("vazia: %s\n", (vazia(f))? "Sim" : "Nao"); return 0; 29 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
20 Estrutura de Dados Filas Estruturas TCelula e TFila 1 #include<stdio.h> 2 #include<stdlib.h> 3 4 struct Celula { 5 char info; 6 struct Celula *prox; 7 }; typedef struct Celula TCelula; 11 typedef struct { 12 TCelula *frente; 13 TCelula *tras; 14 } TFila; Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
21 Estrutura de Dados Filas Função inicializa 15 TFila* inicializa(){ 16 TFila *f = (TFila*) malloc (sizeof(tfila)); 17 f->frente = (TCelula*) malloc (sizeof(tcelula)); 18 f->tras = f->frente; 19 f->frente->prox = NULL; 20 return f; 21 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
22 Estrutura de Dados Filas Função vazia 22 int vazia(tfila* f){ 23 return (f->frente == f->tras); 24 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
23 Estrutura de Dados Filas Função enfileira 25 void enfileira(tfila *f, char c){ 26 TCelula* novo = (TCelula*) malloc (sizeof(tcelula)); 27 novo->info = c; 28 novo->prox = NULL; 29 f->tras->prox = novo; 30 f->tras = f->tras->prox; 31 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
24 Estrutura de Dados Filas Função desenfileira 32 int desenfileira(tfila *f){ 33 TCelula* aux; 34 if ( vazia(f) ){ 35 printf("erro: Fila esta vazia.\n"); 36 return -1; 37 } 38 aux = f->frente; 39 f->frente = f->frente->prox; 40 free(aux); 41 return f->frente->info; 42 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
25 Estrutura de Dados Pilhas Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
26 Estrutura de Dados Pilhas Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
27 Estrutura de Dados Pilhas Conceito (pense abstrato) 1 int main (int argc, char* argv[]){ 2 TPilha* p; 3 p = inicializa(); 4 printf("vazia: %s\n", (vazia(p))? "Sim" : "Nao"); 5 6 empilha(p, A ); printf("tamanho: %d\n",p->tamanho); 7 printf("vazia: %s\n", (vazia(p))? "Sim" : "Nao"); 8 9 empilha(p, B ); 10 empilha(p, C ); printf("tamanho: %d\n",p->tamanho); printf("desempilhou: %c\n", desempilha(p)); 13 printf("desempilhou: %c\n", desempilha(p)); 14 printf("desempilhou: %c\n", desempilha(p)); if (!vazia(p)){ 17 printf("desempilhou: %c\n", desempilha(p)); 18 } empilha(p, D ); 21 empilha(p, E ); printf("tamanho: %d\n",p->tamanho); while (!vazia(p)){ 24 printf("desempilhou: %c\n", desempilha(p)); 25 } 26 printf("vazia: %s\n", (vazia(p))? "Sim" : "Nao"); return 0; 29 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
28 Estrutura de Dados Pilhas Estruturas TCelula e TPilha 1 #include<stdio.h> 2 #include<stdlib.h> 3 4 struct Celula { 5 char info; 6 struct Celula *prox; 7 }; typedef struct Celula TCelula; 11 typedef struct { 12 TCelula *fundo; 13 TCelula *topo; 14 int tamanho; 15 } TPilha; Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
29 Estrutura de Dados Pilhas Função inicializa 16 TPilha* inicializa(){ 17 TPilha *p = (TPilha*) malloc (sizeof(tpilha)); 18 p->topo = (TCelula*) malloc (sizeof(tcelula)); 19 p->fundo = p->topo; 20 p->topo->prox = NULL; 21 p->tamanho = 0; 22 return p; 23 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
30 Estrutura de Dados Pilhas Função vazia 24 int vazia(tpilha* p){ 25 return (p->topo == p->fundo); 26 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
31 Estrutura de Dados Pilhas Função tamanho 27 int tamanho(tpilha* p){ 28 return p->tamanho; 29 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
32 Estrutura de Dados Pilhas Função empilha 31 void empilha(tpilha *p, char c){ 32 TCelula* novo = (TCelula*) malloc (sizeof(tcelula)); 33 novo->prox = p->topo; 34 p->topo->info = c; 35 p->topo = novo; 36 p->tamanho++; 37 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
33 Estrutura de Dados Pilhas Função desempilha 38 int desempilha(tpilha *p){ 39 TCelula* aux; 40 if ( vazia(p) ){ 41 printf("erro: Pilha esta vazia.\n"); 42 return -1; 43 } 44 aux = p->topo; 45 p->topo = p->topo->prox; 46 free(aux); 47 p->tamanho--; 48 return p->topo->info; 49 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
34 3. Análise de Algoritmos Conteúdo 1 Introdução 3 2 Estrutura de Dados 6 3 Análise de Algoritmos 34 Complexidade 35 Comportamento Assintótico 47 4 Métodos de Ordenação 71 5 Pesquisa em Memória Primária 108 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
35 Análise de Algoritmos Complexidade Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
36 Análise de Algoritmos Complexidade Dois tipos de problemas da área de análise de algoritmos: 1 Análise de um algoritmo em particular Qual é o custo de usar um dado algoritmo para resolver um problema específico? Logo, analisa-se o número de vezes que cada parte do algoritmo é executada 2 Análise de uma classe de algoritmos Qual é o algoritmo de menor custo possível para resolver um problema particular? Logo, toda uma família de algoritmos para resolver um problema específico é analisada para identificar o melhor Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
37 Análise de Algoritmos Complexidade Exemplo Motivador: Ordenação Pergunta-se 1 Como seria um algoritmo para ordenar um arranjo? Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
38 Análise de Algoritmos Complexidade Exemplo Motivador: Ordenação Pergunta-se 1 Como seria um algoritmo para ordenar um arranjo? 2 E qual seria o seu custo de execução? Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
39 Análise de Algoritmos Complexidade Função para ordenar um arranjo (Bubble sort) 1 int i, j, aux; 2 for (i=0; i<tam-1; i++){ 3 for (j=tam-1; j>=i+1; j--){ 4 if (v[j] < v[j-1]){ 5 aux = v[j]; 6 v[j] = v[j-1]; 7 v[j-1] = aux; 8 } 9 } 10 } 11 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
40 Análise de Algoritmos Complexidade Exemplo Motivador: Achar o maior valor Pergunta-se 1 Como seria um algoritmo para encontrar o maior valor de um arranjo? Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
41 Análise de Algoritmos Complexidade Exemplo Motivador: Achar o maior valor Pergunta-se 1 Como seria um algoritmo para encontrar o maior valor de um arranjo? 2 E qual seria o seu custo de execução? Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
42 Análise de Algoritmos Complexidade Função para obter o máximo de um conjunto 1 int max(int v[], int tam){ 2 int i; 3 int maior = v[0]; 4 5 for (i=1; i<tam; i++){ 6 if ( v[i] > maior ){ 7 maior = v[i]; 8 } 9 } 10 return maior; 11 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
43 Análise de Algoritmos Complexidade Medir o custo de execução Define-se uma função de complexidade f (a.k.a. função de custo) Logo, f (n) é a medida do tempo necessário para executar um algoritmo para um problema de tamanho n Se f considera tempo função de complexidade de tempo f Se f considera quantidade de memória função de complexidade de memória f Neste material, f denotará sempre função de complexidade de tempo Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
44 Análise de Algoritmos Complexidade Função para obter o máximo de um conjunto 1 int max(int v[], int tam){ 2 int i; 3 int maior = v[0]; 4 5 for (i=1; i<tam; i++){ 6 if ( v[i] > maior ){ 7 maior = v[i]; 8 } 9 } 10 return maior; 11 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
45 Análise de Algoritmos Complexidade Função para obter o máximo de um conjunto 1 int max(int v[], int tam){ 2 int i; 3 int maior = v[0]; 4 5 for (i=1; i<tam; i++){ 6 if ( v[i] > maior ){ 7 maior = v[i]; 8 } 9 } 10 return maior; 11 } Seja f uma função de complexidade tal que f (n) é o número de comparações entre os elementos de v, se v contiver n elementos. Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
46 Análise de Algoritmos Complexidade Função para obter o máximo de um conjunto 1 int max(int v[], int tam){ 2 int i; 3 int maior = v[0]; 4 5 for (i=1; i<tam; i++){ 6 if ( v[i] > maior ){ 7 maior = v[i]; 8 } 9 } 10 return maior; 11 } Seja f uma função de complexidade tal que f (n) é o número de comparações entre os elementos de v, se v contiver n elementos. f (n) = n 1 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
47 Análise de Algoritmos Complexidade Algoritmo ótimo Quando o custo de um algoritmo é igual ao menor custo possível, podemos afirmar que o algoritmo é ótimo Pergunta-se O algoritmo Max é ótimo? Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
48 Análise de Algoritmos Complexidade Pesquisa sequencial 1 int pesquisasequencial(int v[], int tam, int x){ 2 int i; 3 for (i=0; i<tam; i++){ 4 if ( v[i] == x ){ 5 return i; 6 } 7 } 8 return -1; 9 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
49 Análise de Algoritmos Complexidade Pesquisa sequencial 1 int pesquisasequencial(int v[], int tam, int x){ 2 int i; 3 for (i=0; i<tam; i++){ 4 if ( v[i] == x ){ 5 return i; 6 } 7 } 8 return -1; 9 } Seja f uma função de complexidade tal que f (n) é o número de elementos de v consultados, se v contiver n elementos Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
50 Análise de Algoritmos Complexidade Pesquisa sequencial 1 int pesquisasequencial(int v[], int tam, int x){ 2 int i; 3 for (i=0; i<tam; i++){ 4 if ( v[i] == x ){ 5 return i; 6 } 7 } 8 return -1; 9 } Seja f uma função de complexidade tal que f (n) é o número de elementos de v consultados, se v contiver n elementos Melhor caso: f (n) = 1 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
51 Análise de Algoritmos Complexidade Pesquisa sequencial 1 int pesquisasequencial(int v[], int tam, int x){ 2 int i; 3 for (i=0; i<tam; i++){ 4 if ( v[i] == x ){ 5 return i; 6 } 7 } 8 return -1; 9 } Seja f uma função de complexidade tal que f (n) é o número de elementos de v consultados, se v contiver n elementos Melhor caso: f (n) = 1 Pior caso: f (n) = n Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
52 Análise de Algoritmos Complexidade Pesquisa sequencial 1 int pesquisasequencial(int v[], int tam, int x){ 2 int i; 3 for (i=0; i<tam; i++){ 4 if ( v[i] == x ){ 5 return i; 6 } 7 } 8 return -1; 9 } Seja f uma função de complexidade tal que f (n) é o número de elementos de v consultados, se v contiver n elementos Melhor caso: f (n) = 1 Pior caso: f (n) = n Caso médio: f (n) = n Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
53 Análise de Algoritmos Complexidade Função para obter o máximo e o mínimo de um conjunto (v.1) 1 void maxmin1(int v[], int tam, int *max, int *min){ 2 int i; 3 *max = *min = v[0]; 4 for (i=1; i<tam; i++){ 5 if ( v[i] > *max ){ 6 *max = v[i]; 7 } 8 if ( v[i] < *min ){ 9 *min = v[i]; 10 } 11 } 12 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
54 Análise de Algoritmos Complexidade Função para obter o máximo e o mínimo de um conjunto (v.1) 1 void maxmin1(int v[], int tam, int *max, int *min){ 2 int i; 3 *max = *min = v[0]; 4 for (i=1; i<tam; i++){ 5 if ( v[i] > *max ){ 6 *max = v[i]; 7 } 8 if ( v[i] < *min ){ 9 *min = v[i]; 10 } 11 } 12 } Seja f uma função de complexidade tal que f (n) é o número de comparações entre os elementos de v, se v contiver n elementos. Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
55 Análise de Algoritmos Complexidade Função para obter o máximo e o mínimo de um conjunto (v.1) 1 void maxmin1(int v[], int tam, int *max, int *min){ 2 int i; 3 *max = *min = v[0]; 4 for (i=1; i<tam; i++){ 5 if ( v[i] > *max ){ 6 *max = v[i]; 7 } 8 if ( v[i] < *min ){ 9 *min = v[i]; 10 } 11 } 12 } Seja f uma função de complexidade tal que f (n) é o número de comparações entre os elementos de v, se v contiver n elementos. f (n) = 2(n 1) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
56 Análise de Algoritmos Complexidade Função para obter o máximo e o mínimo de um conjunto (v.2) 1 void maxmin1(int v[], int tam, int *max, int *min){ 2 int i; 3 *max = *min = v[0]; 4 for (i=1; i<tam; i++){ 5 if ( v[i] > *max ){ 6 *max = v[i]; 7 } else if ( v[i] < *min ){ 8 *min = v[i]; 9 } 10 } 11 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
57 Análise de Algoritmos Complexidade Função para obter o máximo e o mínimo de um conjunto (v.2) 1 void maxmin1(int v[], int tam, int *max, int *min){ 2 int i; 3 *max = *min = v[0]; 4 for (i=1; i<tam; i++){ 5 if ( v[i] > *max ){ 6 *max = v[i]; 7 } else if ( v[i] < *min ){ 8 *min = v[i]; 9 } 10 } 11 } Seja f uma função de complexidade tal que f (n) é o número de elementos de v consultados, se v contiver n elementos. Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
58 Análise de Algoritmos Complexidade Função para obter o máximo e o mínimo de um conjunto (v.2) 1 void maxmin1(int v[], int tam, int *max, int *min){ 2 int i; 3 *max = *min = v[0]; 4 for (i=1; i<tam; i++){ 5 if ( v[i] > *max ){ 6 *max = v[i]; 7 } else if ( v[i] < *min ){ 8 *min = v[i]; 9 } 10 } 11 } Seja f uma função de complexidade tal que f (n) é o número de elementos de v consultados, se v contiver n elementos. Melhor caso: f (n) = n 1 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
59 Análise de Algoritmos Complexidade Função para obter o máximo e o mínimo de um conjunto (v.2) 1 void maxmin1(int v[], int tam, int *max, int *min){ 2 int i; 3 *max = *min = v[0]; 4 for (i=1; i<tam; i++){ 5 if ( v[i] > *max ){ 6 *max = v[i]; 7 } else if ( v[i] < *min ){ 8 *min = v[i]; 9 } 10 } 11 } Seja f uma função de complexidade tal que f (n) é o número de elementos de v consultados, se v contiver n elementos. Melhor caso: f (n) = n 1 Pior caso: f (n) = 2(n 1) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
60 Análise de Algoritmos Complexidade Função para obter o máximo e o mínimo de um conjunto (v.2) 1 void maxmin1(int v[], int tam, int *max, int *min){ 2 int i; 3 *max = *min = v[0]; 4 for (i=1; i<tam; i++){ 5 if ( v[i] > *max ){ 6 *max = v[i]; 7 } else if ( v[i] < *min ){ 8 *min = v[i]; 9 } 10 } 11 } Seja f uma função de complexidade tal que f (n) é o número de elementos de v consultados, se v contiver n elementos. Melhor caso: f (n) = n 1 Pior caso: f (n) = 2(n 1) Caso médio: f (n) = 3n 3 2 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
61 Análise de Algoritmos Comportamento Assintótico Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
62 Análise de Algoritmos Comportamento Assintótico Comportamento Assintótico de Funções A escolha do algoritmo não é um problema para problemas de tamanho pequeno Logo, a análise de algoritmos é realizada para valores grandes de n Para tal, considera-se o comportamento de suas funções de custo para valores grandes de n i.e., estuda-se o comportamento assintótico das funções de custo O comportamento assintótico de f (n) representa o limite do comportamento do custo quando n cresce Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
63 Análise de Algoritmos Comportamento Assintótico Definição Uma função f (n) domina assintoticamente outra função g(n) se existem duas constantes positivas c e n 0 tais que, para n n 0, temos g(n) c x f (n) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
64 y Análise de Algoritmos Comportamento Assintótico Exemplo Sejam: g(n) = (n + 1) 2 f (n) = n (n+1)^2 n^2 4(n^2) x Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
65 y Análise de Algoritmos Comportamento Assintótico Exemplo Sejam: g(n) = (n + 1) 2 f (n) = n (n+1)^2 n^2 4(n^2) As funções g(n) e f (n) dominam assintoticamente uma a outra, já que (n + 1) 2 c n 2 para c = 4 e n 0 = 1 0 n 2 c (n + 1) x para c = 1 e n 0 = 0 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
66 y Análise de Algoritmos Comportamento Assintótico Exemplo Sejam: f (n) = n g(n) = n n -n^ x Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
67 y Análise de Algoritmos Comportamento Assintótico Exemplo Sejam: f (n) = n 4 g(n) = n 2 A função g(n) domina assintoticamente f (n), já que 3 n c n 2 2 n -n^2 para c = 1 e n 0 = x Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
68 y Análise de Algoritmos Comportamento Assintótico Exemplo Sejam: f (n) = n 4 g(n) = n 2 A função g(n) domina assintoticamente f (n), já que 3 n c n 2 2 n -n^2 para c = 1 e n 0 = x No entanto, a função f (n) não domina assintoticamente g(n), já que n 2 > c x n para todo n > c e n > 1 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
69 Análise de Algoritmos Comportamento Assintótico Definição notação O Limite Assintótico Superior Uma função f (n) é O(g(n)) se existem duas constantes positivas c e n 0 tais que f (n) c x g(n), para todo n n 0 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
70 Análise de Algoritmos Comportamento Assintótico Exemplo Seja f (n) = (n + 1) 2 Pergunta-se: f (n) é O(n 2 )? f (n) é O(n 3 )? f (n) é O(n 4 )? Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
71 Análise de Algoritmos Comportamento Assintótico Exemplo Seja f (n) = (n + 1) 2 Pergunta-se: f (n) é O(n 2 )? Sim, assumindo c = 4 e n 0 = 1 f (n) é O(n 3 )? f (n) é O(n 4 )? Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
72 Análise de Algoritmos Comportamento Assintótico Exemplo Seja f (n) = (n + 1) 2 Pergunta-se: f (n) é O(n 2 )? Sim, assumindo c = 4 e n 0 = 1 f (n) é O(n 3 )? Sim f (n) é O(n 4 )? Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
73 Análise de Algoritmos Comportamento Assintótico Exemplo Seja f (n) = (n + 1) 2 Pergunta-se: f (n) é O(n 2 )? Sim, assumindo c = 4 e n 0 = 1 f (n) é O(n 3 )? Sim f (n) é O(n 4 )? Sim Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
74 Análise de Algoritmos Comportamento Assintótico Exemplo Seja f (n) = 3n 3 + 2n 2 + n Pergunta-se: f (n) é O(n 2 )? f (n) é O(n 3 )? f (n) é O(n 4 )? Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
75 Análise de Algoritmos Comportamento Assintótico Exemplo Seja f (n) = 3n 3 + 2n 2 + n Pergunta-se: f (n) é O(n 2 )? Não f (n) é O(n 3 )? f (n) é O(n 4 )? Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
76 Análise de Algoritmos Comportamento Assintótico Exemplo Seja f (n) = 3n 3 + 2n 2 + n Pergunta-se: f (n) é O(n 2 )? Não f (n) é O(n 3 )? Sim, assumindo c = 6 e n 0 = 0 f (n) é O(n 4 )? Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
77 Análise de Algoritmos Comportamento Assintótico Exemplo Seja f (n) = 3n 3 + 2n 2 + n Pergunta-se: f (n) é O(n 2 )? Não f (n) é O(n 3 )? Sim, assumindo c = 6 e n 0 = 0 f (n) é O(n 4 )? Sim Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
78 Análise de Algoritmos Comportamento Assintótico Definição notação Ω Limite Assintótico Inferior Uma função f (n) é Ω(g(n)) se existem duas constantes positivas c e n 0 tais que f (n) c x g(n), para todo n n 0 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
79 Análise de Algoritmos Comportamento Assintótico Exemplo Seja f (n) = 3n 3 + 2n 2 Pergunta-se: f (n) é Ω(n 3 )? f (n) é Ω(n 2 )? Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
80 Análise de Algoritmos Comportamento Assintótico Exemplo Seja f (n) = 3n 3 + 2n 2 Pergunta-se: f (n) é Ω(n 3 )? Sim, assumindo c = 1 e n 0 = 0 f (n) é Ω(n 2 )? Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
81 Análise de Algoritmos Comportamento Assintótico Exemplo Seja f (n) = 3n 3 + 2n 2 Pergunta-se: f (n) é Ω(n 3 )? Sim, assumindo c = 1 e n 0 = 0 f (n) é Ω(n 2 )? Sim Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
82 Análise de Algoritmos Comportamento Assintótico Definição notação Θ Limite Assintótico Firme Uma função f (n) é Θ(g(n)) se existem constantes positivas c 1, c 2 e n 0 tais que 0 c 1 x g(n) f (n) c 2 x g(n), para todo n n 0 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
83 Análise de Algoritmos Comportamento Assintótico Exemplo Seja f (n) = n2 3 2n Pergunta-se: f (n) é Θ(n 2 )? Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
84 Análise de Algoritmos Comportamento Assintótico Exemplo Seja f (n) = n2 3 2n Pergunta-se: f (n) é Θ(n 2 )? Sim, assumindo c 1 = 1 21, c 2 = 1 3 e m = 7 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
85 Análise de Algoritmos Comportamento Assintótico Classes de Comportamento Assintótico f (n) = O(1): complexidade constante f (n) = O(lg n): complexidade logarítmica f (n) = O(n): complexidade linear f (n) = O(n lg n): complexidade sem nome definido f (n) = O(n 2 ): complexidade quadrática f (n) = O(n 3 ): complexidade cúbica f (n) = O(2 n ): complexidade exponencial f (n) = O(n!): complexidade fatorial Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
86 Análise de Algoritmos Comportamento Assintótico Classes de Comportamento Assintótico 60 y f(n) = 1 lg(n) n n*lg(n) n^2 n^3 2^n n! x Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
87 Análise de Algoritmos Comportamento Assintótico Complexidade constante f (n) = O(1) Independe do tamanho de n Instruções são executadas um número fixo de vezes Exemplo: algoritmo de inserção de um aluno Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
88 Análise de Algoritmos Comportamento Assintótico Complexidade logarítmica f (n) = O(lg n) Ocorre normalmente em problemas que dividem o problema em problemas menores Exemplo: busca binária Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
89 Análise de Algoritmos Comportamento Assintótico Complexidade linear f (n) = O(n) Em geral, um pequeno trabalho é realizado uma única vez sobre cada elemento da entrada Se o tamanho dobra, o tempo de execução também dobra Exemplo: pesquisa sequencial Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
90 Análise de Algoritmos Comportamento Assintótico Complexidade sem nome definido f (n) = O(n lg n) Ocorre normalmente em problemas que dividem o problema em problemas menores No entanto, resolvendo cada um deles independentemente e depois juntando as soluções Se o tamanho dobra, o tempo de execução é um pouco mais que o dobro Exemplo: MergeSort, QuickSort, HeapSort... Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
91 Análise de Algoritmos Comportamento Assintótico Complexidade quadrática f (n) = O(n 2 ) Em geral, itens processados aos pares Normalmente, um for dentro do outro (i e j) Se o tamanho dobra, o tempo de execução é o dobro do dobro (i.e., multiplica por 4) Exemplo: seleção, bolha, pesquisa em matriz bi-dimensional... Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
92 Análise de Algoritmos Comportamento Assintótico Complexidade cúbica f (n) = O(n 3 ) Algoritmos dessa ordem de complexidade só são úteis para resolver pequenos problemas Normalmente, um for dentro de outro for dentro de outro (i, j e k) Se o tamanho dobra, o tempo de execução é o dobro do dobro do dobro (i.e., multiplica por 8) Exemplo: pesquisa em matriz tri-dimensional, multiplicação de matrizes quadradas... Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
93 Análise de Algoritmos Comportamento Assintótico Complexidade exponencial f (n) = O(2 n ) Algoritmos dessa ordem de complexidade já não são úteis do ponto de vista prático Normalmente vinculado ao uso de força bruta Se o tamanho dobra, o tempo de execução fica elevado ao quadrado Exemplo: Problema do Caixeiro Viajante usando programação dinâmica Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
94 Análise de Algoritmos Comportamento Assintótico Complexidade fatorial f (n) = O(n!) Algoritmos dessa ordem de complexidade são ditos de complexidade exponencial Apesar de n! ser muito pior que 2 n não são úteis do ponto de vista prático Normalmente também vinculado ao uso de força bruta Se o tamanho dobra, o tempo de execução fica muito mais do que elevado ao quadrado Exemplo: Problema do Caixeiro Viajante Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
95 Análise de Algoritmos Comportamento Assintótico Classes de Comportamento Assintótico Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
96 Análise de Algoritmos Comportamento Assintótico Exercício Seja um algoritmo A, de complexidade de tempo O(n 5 ), e um algoritmo B, de complexidade de tempo O(2 n ), que resolvem o mesmo problema. O algoritmo A é considerado pela literatura como o algoritmo ótimo para o problema. No entanto, o usuário alega que o algoritmo B é mais rápido que o algoritmo A. Onde se encontra o erro? Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
97 Análise de Algoritmos Comportamento Assintótico Exercício Seja um algoritmo A, de complexidade de tempo O(n 5 ), e um algoritmo B, de complexidade de tempo O(2 n ), que resolvem o mesmo problema. O algoritmo A é considerado pela literatura como o algoritmo ótimo para o problema. No entanto, o usuário alega que o algoritmo B é mais rápido que o algoritmo A. Onde se encontra o erro? Resposta: n 5 é O(2 n ), para c = 1 e n 0 = 23 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
98 4. Métodos de Ordenação Conteúdo 1 Introdução 3 2 Estrutura de Dados 6 3 Análise de Algoritmos 34 4 Métodos de Ordenação 71 Conceitualização 72 SelectionSort (Seleção) 77 BubbleSort (Bolha) 83 InsertionSort (Inserção) 87 ShellSort 94 QuickSort 99 5 Pesquisa em Memória Primária 108 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
99 Métodos de Ordenação Conceitualização Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
100 Métodos de Ordenação Conceitualização Os algoritmos de ordenação constituem bons exemplos de como resolver problemas utilizando computadores Vários algoritmos para o mesmo problema Cada um com uma vantagem particular Neste material, o foco será em ordenar um arranjo de inteiros No entanto, os algoritmos se estendem a qualquer estrutura passível de ordenação (e.g., nomes, salários, etc.) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
101 Métodos de Ordenação Conceitualização Classificação Ordenação Interna: Utilizado quando o arquivo a ser ordenado cabe todo na memória principal (foco da disciplina) Ordenação Externa: Utilizado quando o arquivo a ser ordenado não cabe na memória principal logo parte deve ser armazenada no disco enquanto outra é ordenada na memória Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
102 Métodos de Ordenação Conceitualização Método de ordenação estável Preserva a ordem relativa dos itens com chaves iguais Exemplo: [ Alfredo 500, Bernardo, Carlos , Diego 500 ] ordenar por salário uma lista de funcionários já ordenada por nome Método de ordenação sensível a entrada O fato de já estar ordenado, parcialmente ordenado ou inversamente ordenado interfere na função de complexidade f (n) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
103 Métodos de Ordenação Conceitualização Métodos Simples: SelectionSort (Seleção), BubbleSort (Bolha), InsertionSort (Inserção) internos O(n 2 ) pequenos arquivos Análise C(n) e M(n) Métodos Eficientes: ShellSort, QuickSort internos O(n lg(n)) grandes arquivos Análise C(n) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
104 Métodos de Ordenação SelectionSort (Seleção) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
105 Métodos de Ordenação SelectionSort (Seleção) SelectionSort 1 void selectionsort(int v[], int tam){ 2 int i, j, min, aux; 3 for (i=0; i<tam-1; i++){ 4 min = i; 5 for (j=i+1; j<tam; j++){ 6 if (v[j] < v[min]){ 7 min = j; 8 } 9 } 10 aux = v[min]; 11 v[min] = v[i]; 12 v[i] = aux; 13 } 14 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
106 Métodos de Ordenação SelectionSort (Seleção) Análise por número de comparações C(n) C(n) = n 1 i=1... n j=i+1 1 C(n) = Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
107 Métodos de Ordenação SelectionSort (Seleção) Análise por número de comparações C(n) C(n) = n 1 i=1... n j=i+1 1 C(n) = n2 2 n 2 = O( ) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
108 Métodos de Ordenação SelectionSort (Seleção) Análise por número de comparações C(n) C(n) = n 1 i=1... n j=i+1 1 C(n) = n2 2 n 2 = O(n2 ) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
109 Métodos de Ordenação SelectionSort (Seleção) Análise por número de movimentações M(n) n 1 M(n) = 3... i=1 M(n) = Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
110 Métodos de Ordenação SelectionSort (Seleção) Análise por número de movimentações M(n) n 1 M(n) = 3... i=1 M(n) = 3(n 1) = O( ) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
111 Métodos de Ordenação SelectionSort (Seleção) Análise por número de movimentações M(n) n 1 M(n) = 3... i=1 M(n) = 3(n 1) = O(n) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
112 Métodos de Ordenação SelectionSort (Seleção) SelectionSort Resumo Ordenação interna C(n) = O(n 2 ) M(n) = O(n) não é estável não é sensível à entrada e.g., arquivo já ordenado não ajuda em nada Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
113 Métodos de Ordenação SelectionSort (Seleção) SelectionSort Exemplo Completo 1 void selectionsort(int v[], int tam){ 2 int i, j, min, aux; 3 for (i=0; i<tam-1; i++){ 4 min = i; 5 for (j=i+1; j<tam; j++){ 6 if (v[j] < v[min]){ 7 min = j; 8 } 9 } 10 aux = v[min]; 11 v[min] = v[i]; 12 v[i] = aux; 13 } 14 } int main (int argc, char* argv[]){ 17 int v[] = {5,2,4,6,1,3}; 18 int i; 19 int tam = sizeof(v)/sizeof(int); 20 selectionsort(v, tam); for (i=0; i<tam; i++){ 23 printf("%d\t", v[i]); 24 } 25 printf("\n"); 26 return 0; 27 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
114 Métodos de Ordenação BubbleSort (Bolha) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
115 Métodos de Ordenação BubbleSort (Bolha) BubbleSort 1 void bubblesort(int v[], int tam){ 2 int i, j, aux; 3 for (i=0; i<tam-1; i++){ 4 for (j=tam-1; j>=i+1; j--){ 5 if (v[j] < v[j-1]){ 6 aux = v[j]; 7 v[j] = v[j-1]; 8 v[j-1] = aux; 9 } 10 } 11 } 12 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
116 Métodos de Ordenação BubbleSort (Bolha) BubbleSort Resumo Ordenação interna C(n) = O(n 2 ) M(n) = O(n 2 ) não é estável sensível à entrada (mas por quê?) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
117 Métodos de Ordenação BubbleSort (Bolha) BubbleSort Exemplo Completo 1 void bubblesort(int v[], int tam){ 2 int i, j, aux; 3 for (i=0; i<tam-1; i++){ 4 for (j=tam-1; j>=i+1; j--){ 5 if (v[j] < v[j-1]){ 6 aux = v[j]; 7 v[j] = v[j-1]; 8 v[j-1] = aux; 9 } 10 } 11 } 12 } int main (int argc, char* argv[]){ 15 int v[] = {5,2,4,6,1,3}; 16 int i; 17 int tam = sizeof(v)/sizeof(int); 18 bubblesort(v, tam); for (i=0; i<tam; i++){ 21 printf("%d\t", v[i]); 22 } 23 printf("\n"); 24 return 0; 25 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
118 Métodos de Ordenação InsertionSort (Inserção) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
119 Métodos de Ordenação InsertionSort (Inserção) InsertionSort 1 void insertionsort(int v[], int tam){ 2 int i, j, key; 3 for (i=1; i<tam; i++){ 4 key = v[i]; 5 /* Insere v[i] na sequencia ordenada v[0..i-1] */ 6 j = i-1; 7 while (j >= 0 && v[j] > key){ 8 v[j+1] = v[j]; 9 j--; 10 } 11 v[j+1] = key; 12 } 13 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
120 Métodos de Ordenação InsertionSort (Inserção) Análise por número de comparações C(n) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
121 Métodos de Ordenação InsertionSort (Inserção) Análise por número de comparações C(n) Melhor caso : C(n) = ( ) = n 1 = O(n) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
122 Métodos de Ordenação InsertionSort (Inserção) Análise por número de comparações C(n) Melhor caso : C(n) = ( ) = n 1 = O(n) Pior caso : C(n) = ( n) = n2 2 + n 2 1 = O(n2 ) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
123 Métodos de Ordenação InsertionSort (Inserção) Análise por número de comparações C(n) Melhor caso : C(n) = ( ) = n 1 = O(n) Pior caso : C(n) = ( n) = n2 2 + n 2 1 = O(n2 ) Caso medio : C(n) = n n 4 1 = O(n2 ) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
124 Métodos de Ordenação InsertionSort (Inserção) Análise por número de movimentações M(n) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
125 Métodos de Ordenação InsertionSort (Inserção) Análise por número de movimentações M(n) Melhor caso : M(n) = ( ) = 3(n 1) = O(n) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
126 Métodos de Ordenação InsertionSort (Inserção) Análise por número de movimentações M(n) Melhor caso : M(n) = ( ) = 3(n 1) = O(n) Pior caso : M(n) = ( n + 2) = n n 2 3 = O(n2 ) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
127 Métodos de Ordenação InsertionSort (Inserção) Análise por número de movimentações M(n) Melhor caso : M(n) = ( ) = 3(n 1) = O(n) Pior caso : M(n) = ( n + 2) = n n 2 3 = O(n2 ) Caso medio : C(n) = n n 4 3 = O(n2 ) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
128 Métodos de Ordenação InsertionSort (Inserção) InsertionSort Resumo Ordenação interna C(n) = O(n 2 ), mas M(n) = O(n 2 ), mas estável sensível à entrada InsertionSort Uso na prática Em um arquivo já quase ordenado Em inserções de alguns poucos registros em um arquivo já ordenado e depois obter um outro arquivo ordenado Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
129 Métodos de Ordenação InsertionSort (Inserção) InsertionSort Resumo Ordenação interna C(n) = O(n 2 ), mas C(n) = Ω(n) M(n) = O(n 2 ), mas M(n) = Ω(n) estável sensível à entrada InsertionSort Uso na prática Em um arquivo já quase ordenado Em inserções de alguns poucos registros em um arquivo já ordenado e depois obter um outro arquivo ordenado Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
130 Métodos de Ordenação InsertionSort (Inserção) InsertionSort Exemplo Completo 1 void insertionsort(int v[], int tam){ 2 int i, j, key; 3 for (i=1; i<tam; i++){ 4 key = v[i]; 5 /* Insere v[i] na sequencia ordenada v[0..i-1] */ 6 j = i-1; 7 while (j >= 0 && v[j] > key){ 8 v[j+1] = v[j]; 9 j--; 10 } 11 v[j+1] = key; 12 } 13 } int main (int argc, char* argv[]){ 17 int v[] = {5,2,4,6,1,3}; 18 int i; 19 int tam = sizeof(v)/sizeof(int); 20 insertionsort(v, tam); for (i=0; i<tam; i++){ 23 printf("%d\t", v[i]); 24 } 25 printf("\n"); 26 return 0; 27 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
131 Métodos de Ordenação InsertionSort (Inserção) Perguntas Relevantes 1 Quando optar pelo SelectionSort ao invés do InsertionSort? 2 Quando InsertionSort deve ser usado? 3 Como evitar a condição j>=0 do while do InsertionSort? 4 Como facilmente otimizar o BubbleSort? Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
132 Métodos de Ordenação ShellSort Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
133 Métodos de Ordenação ShellSort ShellSort 1 void shellsort(int v[], int tam){ 2 static const int gaps[] = {701, 301, 132, 57, 23, 10, 4, 1}; 3 static const int gapssize = sizeof(gaps)/sizeof(int); 4 5 int i, j, h, hindex, key; 6 7 for (hindex = 0; hindex < gapssize; hindex++){ 8 h = gaps[hindex]; 9 for (i = h; i < tam; i++){ 10 key = v[i]; 11 j = i - h; 12 while (j >= 0 && v[j] > key){ 13 v[j+h] = v[j]; 14 j -= h; 15 } 16 v[j+h] = key; 17 } 18 } while(h!= 1); 19 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
134 Métodos de Ordenação ShellSort Análise por número de comparações C(n) Ainda não se sabe o razão pelo qual esse método é eficiente Análise complexa principalmente sequência de incrementos C 1 (n) = O(n 1.25 ) C 2 (n) = O(n lg(n)) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
135 Métodos de Ordenação ShellSort ShellSort Resumo Ordenação interna C 1 (n) = O(n 1.25 ) C 2 (n) = O(n lg(n)) não é estável sensível à entrada ShellSort Pontos relevantes Análise de sua complexidade entra em problemas matemáticos difíceis Logo, temos apenas conjecturas Incremento não deve ser múltiplo do anterior (Ciura, 2001) Excelente opção para arquivos de tamanho moderado Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
136 Métodos de Ordenação ShellSort ShellSort Exemplo Completo 1 void shellsort(int v[], int tam){ 2 static const int gaps[] = {701, 301, 132, 57, 23, 10, 4, 1}; 3 static const int gapssize = sizeof(gaps)/sizeof(int); 4 5 int i, j, h, hindex, key; 6 7 for (hindex = 0; hindex < gapssize; hindex++){ 8 h = gaps[hindex]; 9 for (i = h; i < tam; i++){ 10 key = v[i]; 11 j = i - h; 12 while (j >= 0 && v[j] > key){ 13 v[j+h] = v[j]; 14 j -= h; 15 } 16 v[j+h] = key; 17 } 18 } while(h!= 1); 19 } int main (int argc, char* argv[]){ 22 int v[] = {5,2,4,6,1,3}; 23 int i; 24 int tam = sizeof(v)/sizeof(int); 25 shellsort(v, tam); 26 /* um for que imprime o arranjo ordenado */ 27 return 0; 28 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
137 Métodos de Ordenação QuickSort Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
138 Métodos de Ordenação QuickSort QuickSort Proposto por Hoare em 1960 estudante visitante da Universidade de Moscou ideia: Partir um problema de ordenar um conjunto com n itens em dois conjuntos menores estratégia divisão e conquista Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
139 Métodos de Ordenação QuickSort Algoritmo 1 Escolha um item do arranjo e coloque-o em x 2 Percorrer o arranjo da esquerda para direita até que um item v[i] x 3 Analogamente da direita para esquerda até que v[j] x seja encontrado 4 como v[i] e v[j] estão fora de lugar, troque-os de posição 5 Continue o processo até que i cruze com j (i.e, i > j) Ao final, o arranjo v[esq..dir] está particionado como: itens em v[esq], v[esq + 1],..., v[j] são menores ou iguais a x itens em v[i], v[i + 1],..., v[dir] são maiores ou iguais a x Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
140 Métodos de Ordenação QuickSort QuickSort (continua...) 1 void quicksort(int v[], int tam){ 2 quicksortordena(v,0,tam-1); 3 } 4 5 void quicksortordena(int v[], int esq, int dir){ 6 int i, j; 7 particao(v,esq,dir,&i,&j); 8 if (esq < j){ 9 quicksortordena(v,esq,j); 10 } 11 if (i < dir){ 12 quicksortordena(v,i,dir); 13 } 14 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
141 Métodos de Ordenação QuickSort QuickSort 1 void particao(int v[], int esq, int dir, int *i, int *j){ 2 int x, aux; 3 *i = esq; 4 *j = dir; 5 x = v[(*i + *j)/2]; /* obtem o pivo x */ 6 do{ 7 while( x > v[*i] ){ 8 (*i)++; 9 } 10 while( x < v[*j] ){ 11 (*j)--; 12 } 13 if (*i <= *j){ 14 aux = v[*i]; 15 v[*i] = v[*j]; 16 v[*j] = aux; 17 (*i)++; 18 (*j)--; 19 } 20 }while(*i<=*j); 21 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
142 Métodos de Ordenação QuickSort Análise por número de comparações C(n) Com uso da mediana dos três o pior caso O(n 2 ) é evitado Melhor caso : C(n) = 2C( n ) + n 1 = n lg(n) n + 1 = O(n lg(n)) 2 Caso medio : C(n) 1.386n lg(n) 0.846n = O(n lg(n)) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
143 Métodos de Ordenação QuickSort QuickSort Pontos relevantes Implementação muito delicada e complexa Requer uma pequena pilha como memória auxiliar Pivô mal escolhido = O(n 2 ) Quando pivô escolhido é algum extremo de um arquivo já ordenado Facilmente evitado com mediana de três itens do arquivo Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
144 Métodos de Ordenação QuickSort QuickSort Resumo Ordenação interna C(n) = O(n lg(n)) não é estável sensível à entrada QuickSort Uso na prática Algoritmo mais eficiente Algoritmo mais usado Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
145 Métodos de Ordenação QuickSort QuickSort Exemplo Completo 1 void quicksort(int [], int); 2 void quicksortordena(int [], int, int); 3 void particao(int [], int, int, int *, int *); 4 5 void quicksort(int v[], int tam){ 6 quicksortordena(v,0,tam-1); 7 } 8 9 void quicksortordena(int v[], int esq, int dir){ 10 int i, j; 11 particao(v,esq,dir,&i,&j); 12 if (esq < j){ 13 quicksortordena(v,esq,j); 14 } 15 if (i < dir){ 16 quicksortordena(v,i,dir); 17 } 18 } 1 int main (int argc, char* argv[]){ 2 int v[] = {5,2,4,6,1,3}; 3 int i; 4 int tam = sizeof(v)/sizeof(int); 5 quicksort(v, tam); 6 7 for (i=0; i<tam; i++){ 8 printf("%d\t", v[i]); 9 } 10 printf("\n"); 11 return 0; 12 } void particao(int v[], int esq, int dir, int *i, int *j){ 21 int x, aux; 22 *i = esq; 23 *j = dir; 24 x = v[(*i + *j)/2]; /* obtem o pivo x */ 25 do{ 26 while( x > v[*i] ){ 27 (*i)++; 28 } 29 while( x < v[*j] ){ 30 (*j)--; 31 } 32 if (*i <= *j){ 33 aux = v[*i]; 34 v[*i] = v[*j]; 35 v[*j] = aux; 36 (*i)++; 37 (*j)--; 38 } 39 }while(*i<=*j); 40 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
146 5. Pesquisa em Memória Primária Conteúdo 1 Introdução 3 2 Estrutura de Dados 6 3 Análise de Algoritmos 34 4 Métodos de Ordenação 71 5 Pesquisa em Memória Primária 108 Pesquisa Sequencial 109 Pesquisa Binária 112 Árvores de Pesquisa 115 Árvores Binárias sem Balanceamento 117 Árvores Binárias com Balanceamento 134 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
147 Pesquisa em Memória Primária Pesquisa Sequencial Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
148 Pesquisa em Memória Primária Pesquisa Sequencial Pesquisa Sequencial, algum problema? 1 int pesquisasequencial(int v[], int tam, int x){ 2 int i; 3 for (i=0; i<tam; i++){ 4 if ( v[i] == x ){ 5 return i; 6 } 7 } 8 return -1; 9 } Seja f uma função de complexidade tal que f (n) é o número de elementos de v consultados, se v contiver n elementos Melhor caso: f (n) = 1 Pior caso: f (n) = n Caso médio: f (n) = n Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
149 Pesquisa em Memória Primária Pesquisa Sequencial Sim! Um algoritmo de pesquisa O(n) pode não ser suficiente O conhecido full scan NUNCA é bom! Existem diversas estruturas de dados voltadas para pesquisa Denominado dicionário Nesta seção abordaremos: Pesquisa Binária com Arranjo Pesquisa Binária com Árvore Binária Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
150 Pesquisa em Memória Primária Pesquisa Binária Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
151 Pesquisa em Memória Primária Pesquisa Binária Pesquisa Binária Uma pesquisa em um arranjo ordenado pode ser muito mais eficiente Pense bem Tec-Toy Exemplo (procurando 9): Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
152 Pesquisa em Memória Primária Pesquisa Binária Pesquisa Binária Uma pesquisa em um arranjo ordenado pode ser muito mais eficiente Pense bem Tec-Toy Exemplo (procurando 9): Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
153 Pesquisa em Memória Primária Pesquisa Binária Pesquisa Binária Uma pesquisa em um arranjo ordenado pode ser muito mais eficiente Pense bem Tec-Toy Exemplo (procurando 9): Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
154 Pesquisa em Memória Primária Pesquisa Binária Pesquisa Binária Uma pesquisa em um arranjo ordenado pode ser muito mais eficiente Pense bem Tec-Toy Exemplo (procurando 9): Problema resolvido? Vamos manter sempre ordenado. Resolvido o problema? Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
155 Pesquisa em Memória Primária Pesquisa Binária Análise A cada interação divide-se o arranjo ao meio Logo, O(lg(n)) No entanto: 1 Tipo Abstrato de Dados Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
156 Pesquisa em Memória Primária Pesquisa Binária Análise A cada interação divide-se o arranjo ao meio Logo, O(lg(n)) No entanto: E o custo para manter ordenado? 1 Tipo Abstrato de Dados Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
157 Pesquisa em Memória Primária Pesquisa Binária Análise A cada interação divide-se o arranjo ao meio Logo, O(lg(n)) No entanto: E o custo para manter ordenado? Algum outro TAD 1 resolve? (e.g., lista, fila, pilha, etc.) 1 Tipo Abstrato de Dados Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
158 Pesquisa em Memória Primária Pesquisa Binária Análise A cada interação divide-se o arranjo ao meio Logo, O(lg(n)) No entanto: E o custo para manter ordenado? Algum outro TAD 1 resolve? (e.g., lista, fila, pilha, etc.) Problema se resolverá? Árvore Binária? 1 Tipo Abstrato de Dados Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
159 Pesquisa em Memória Primária Árvores de Pesquisa Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
160 Pesquisa em Memória Primária Árvores de Pesquisa Árvores de Pesquisa Estrutura de dados muito eficiente Usada quando necessita-se (em totalidade ou parcialmente) acessos direto e sequencial eficientes facilidade de inserção e retirada de registros boa utilização da memória utilização de memória primária e secundária Ampla gama de árvores de pesquisa existentes Árvores Binárias de Pesquisa sem Balanceamento (foco) Árvores Binárias de Pesquisa com Balanceamento (AVL) Árvores B, 2-3, SBB, Trie, Patrícia... Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
161 Pesquisa em Memória Primária Árvores Binárias sem Balanceamento Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
162 Árvores de Pesquisa Árvores Binárias sem Balanceamento Nível 0 Nível 1... Conceitos Célula = Nó (ou nodo) 1 o nodo = raiz Nós no mesmo nível sse mesma distância da raiz Pai = acima Filhos = apontados por esq e dir Subárvore: subconjunto de uma árvore Nó folha: nó sem filhos (i.e., esq = dir = NULL) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
163 Árvores de Pesquisa Árvores Binárias sem Balanceamento Nível 0 Nível 1... Conceitos Altura h de uma árvore = maior distância entre a raiz e um nó folha lg(n + 1) 1 h n 1 Se h = lg(n + 1) 1 árvore cheia Se h = n 1 a árvore é um tronco Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
164 Árvores de Pesquisa Árvores Binárias sem Balanceamento Conceito (pense abstrato) 1 int main (int argc, char* argv[]){ 2 TNo* arvore; 3 int i = 0; 4 arvore = inicializa(); 5 6 char letras[] = { G, H, B, I, A, E, C, F, D, J }; 7 8 for (; i<sizeof(letras)/sizeof(char); i++){ 9 insere(&arvore, letras[i]); 10 } central(arvore); printf("\n"); 13 preordem(arvore); printf("\n"); 14 posordem(arvore); printf("\n"); retira(&arvore, J ); 17 retira(&arvore, H ); 18 retira(&arvore, B ); 19 retira(&arvore, N ); central(arvore); printf("\n"); 22 preordem(arvore); printf("\n"); printf("tem A? %s\n", (pesquisa(arvore, A ))? "S" : "N" ); 25 printf("tem B? %s\n", (pesquisa(arvore, B ))? "S" : "N" ); return 0; 28 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
165 Árvores de Pesquisa Árvores Binárias sem Balanceamento Conceito (pense abstrato) 1 int main (int argc, char* argv[]){ 2 TNo* arvore; 3 int i = 0; 4 arvore = inicializa(); 5 6 char letras[] = { G, H, B, I, A, E, C, F, D, J }; 7 8 for (; i<sizeof(letras)/sizeof(char); i++){ 9 insere(&arvore, letras[i]); 10 } central(arvore); printf("\n"); 13 preordem(arvore); printf("\n"); 14 posordem(arvore); printf("\n"); retira(&arvore, J ); 17 retira(&arvore, H ); 18 retira(&arvore, B ); 19 retira(&arvore, N ); central(arvore); printf("\n"); 22 preordem(arvore); printf("\n"); printf("tem A? %s\n", (pesquisa(arvore, A ))? "S" : "N" ); 25 printf("tem B? %s\n", (pesquisa(arvore, B ))? "S" : "N" ); return 0; 28 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
166 Árvores de Pesquisa Árvores Binárias sem Balanceamento Estrutura TNo 1 struct No { 2 char info; 3 struct No *esq; 4 struct No *dir; 5 }; 6 7 typedef struct No TNo; Função inicializa 1 TNo* inicializa (){ 2 return NULL; 3 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
167 Árvores de Pesquisa Árvores Binárias sem Balanceamento Função insere 1 void insere (TNo **no, char c){ 2 if (*no == NULL){ 3 *no = (TNo*) malloc (sizeof(tno)); 4 (*no)->info = c; 5 (*no)->esq = NULL; 6 (*no)->dir = NULL; 7 return; 8 } 9 if (c < (*no)->info){ 10 insere(&((*no)->esq), c); return; 11 } 12 if (c > (*no)->info){ 13 insere(&((*no)->dir), c); return; 14 } 15 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
168 Árvores de Pesquisa Árvores Binárias sem Balanceamento Função pesquisa 1 int pesquisa(tno *no, char c){ 2 if (no == NULL){ 3 return 0; 4 } 5 if ( c < no->info ){ 6 return pesquisa(no->esq, c); 7 } 8 if ( c > no->info ){ 9 return pesquisa(no->dir, c); 10 } 11 return 1; 12 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
169 Árvores de Pesquisa Árvores Binárias sem Balanceamento Função central 1 void central (TNo *no){ 2 if (no!= NULL){ 3 central(no->esq); 4 printf("%c ",no->info); 5 central(no->dir); 6 } 7 } Resultado A B C D E F G H I J Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
170 Árvores de Pesquisa Árvores Binárias sem Balanceamento Função preordem 1 void preordem (TNo *no){ 2 if (no!= NULL){ 3 printf("%c ",no->info); 4 preordem(no->esq); 5 preordem(no->dir); 6 } 7 } Resultado G B A E C D F H I J Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
171 Árvores de Pesquisa Árvores Binárias sem Balanceamento Função posordem 1 void posordem (TNo *no){ 2 if (no!= NULL){ 3 posordem(no->esq); 4 posordem(no->dir); 5 printf("%c ",no->info); 6 } 7 } Resultado A D C F E B J I H G Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
172 Árvores de Pesquisa Árvores Binárias sem Balanceamento Remoção Forma 1 Retirada de um nodo folha (J) Simples! Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
173 Árvores de Pesquisa Árvores Binárias sem Balanceamento Remoção Forma 2 Retirada de um nodo com um filho (H) Meramente simples! Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
174 Árvores de Pesquisa Árvores Binárias sem Balanceamento Remoção Forma 3 Retirada de um nodo com dois filhos (B) Não tão simples! Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
175 Árvores de Pesquisa Árvores Binárias sem Balanceamento Após as remoções... Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
176 Árvores de Pesquisa Árvores Binárias sem Balanceamento Função retira 1 void retira(tno **no, char c){ 2 TNo *noaux; 3 4 if (*no == NULL){ 5 return; 6 } 7 if ( c < (*no)->info ){ 8 retira(&((*no)->esq), c); return; 9 } 10 if ( c > (*no)->info ){ 11 retira(&((*no)->dir), c); return; 12 } 13 if ( (*no)->dir == NULL ){ 14 noaux = *no; 15 *no = (*no)->esq; 16 free(noaux); 17 return; 18 } 19 if ( (*no)->esq!= NULL ){ 20 antecessor(*no, &((*no)->dir)); return; 21 } 22 noaux = *no; 23 *no = (*no)->dir; 24 free(noaux); 25 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
177 Árvores de Pesquisa Árvores Binárias sem Balanceamento Função antecessor (utilizada na função retira) 1 void antecessor(tno* q, TNo** r){ 2 if ( (*r)->esq!= NULL ){ 3 antecessor(q, &((*r)->esq)); return; 4 } 5 q->info = (*r)->info; 6 q = *r; 7 *r = (*r)->dir; 8 free(q); 9 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
178 Árvores de Pesquisa Árvores Binárias sem Balanceamento Exercícios 1 Implementar a função int altura (TNo* no) que retornará a altura de uma árvore 2 Implementar a função int numerofolhas (TNo* no) que retornará a quantidade de folhas de uma árvore 3 Implementar a função int tamanho (TNo* no) que retornará o numero de nós de uma árvore 4 Implementar a função char menor (TNo* no) que retornará o nó de menor valor de uma árvore 5 Implementar a função int maior (TNo* no) que retornará o nó de maior valor de uma árvore 6 Implementar a função void centraldecrescente (TNo* no) que varrerá a árvore de forma decrescente 7 Realizar a análise de complexidade de cada um dos métodos acima Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
179 Pesquisa em Memória Primária Árvores Binárias com Balanceamento Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
180 Árvores de Pesquisa Árvores Binárias com Balanceamento Árvore Balanceada Definição Popularmente conhecida como Árvore AVL Árvore não Balanceada Tipo especial de Árvore Binária de Pesquisa em que para todos os nós, as sub-árvores direita e esquerda possuem alturas iguais ou com difereça de apenas 1 Melhora o caso médio e evita o pior caso (O(n)) No entanto, o custo para manter a árvore balanceada após cada inserção/remoção é muito alto Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
181 Referências Thomas Cormen. Introduction to algorithms. MIT Press, 3 edition, Paulo Feofiloff. Algoritmos em Linguagem C. Elsevier, Nivio Ziviani. Projeto de algoritmos com implementações em Pascal e C. Cengage Learning, 3 edition, Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, / 136
Ordenação: QuickSort. Prof. Túlio Toffolo BCC202 Aula 15 Algoritmos e Estruturas de Dados I
Ordenação: QuickSort Prof. Túlio Toffolo http://www.toffolo.com.br BCC202 Aula 15 Algoritmos e Estruturas de Dados I QuickSort Proposto por Hoare em 1960 e publicado em 1962. É o algoritmo de ordenação
Teoria da Computação. Aula 3 Comportamento Assintótico 5COP096. Aula 3 Prof. Dr. Sylvio Barbon Junior. Sylvio Barbon Jr
5COP096 Teoria da Computação Aula 3 Prof. Dr. Sylvio Barbon Junior 1 Sumário 1) Exercícios Medida de Tempo de Execução. 2) Comportamento Assintótico de Funções. 3) Exercícios sobre Comportamento Assintótico
BCC202 - Estrutura de Dados I
BCC202 - Estrutura de Dados I Aula 12: Ordenação: Bubble, Selection e Insertion Sort Reinaldo Fortes Universidade Federal de Ouro Preto, UFOP Departamento de Computação, DECOM Website: www.decom.ufop.br/reifortes
INF 1010 Estruturas de Dados Avançadas
INF 1010 Estruturas de Dados Avançadas Complexidade de Algoritmos 2012 DI, PUC-Rio Estruturas de Dados Avançadas 2012.2 1 Introdução Complexidade computacional Termo criado por Hartmanis e Stearns (1965)
Algoritmo. Exemplo. Definição. Programação de Computadores Comparando Algoritmos. Alan de Freitas
Algoritmos Programação de Computadores Comparando Algoritmos Um algoritmo é um procedimento de passos para cálculos. Este procedimento é composto de instruções que definem uma função Até o momento, vimos
Projeto e Análise de Algoritmos
Projeto e Algoritmos Pontifícia Universidade Católica de Minas Gerais [email protected] 26 de Maio de 2017 Sumário A complexidade no desempenho de Quando utilizamos uma máquina boa, ela tende a ter
Análise de Complexidade de Algoritmos. mario alexandre gazziro
Análise de Complexidade de Algoritmos mario alexandre gazziro Definição A complexidade de um algoritmo consiste na quantidade de esforço computacional necessária para sua execução. Esse esforço é expresso
ANÁLISE DE ALGORITMOS: PARTE 3
ANÁLISE DE ALGORITMOS: PARTE 3 Prof. André Backes 2 A notação grande-o é a forma mais conhecida e utilizada de análise Complexidade do nosso algoritmo no pior caso Seja de tempo ou de espaço É o caso mais
Complexidade de algoritmos Notação Big-O
Complexidade de algoritmos Notação Big-O Prof. Byron Leite Prof. Tiago Massoni Engenharia da Computação Poli - UPE Motivação O projeto de algoritmos é influenciado pelo estudo de seus comportamentos Problema
Métodos de Ordenação: Selection, Insertion, Bubble, Merge (Sort)
Métodos de Ordenação: Selection, Insertion, Bubble, Merge (Sort) Hebert Coelho e Nádia Félix Ordenação É a operação de rearranjar os dados em uma determinada ordem. Problema da ordenação - Definição formal
BCC202 - Estrutura de Dados I
BCC202 - Estrutura de Dados I Aula 06: Análise de Algoritmos (Parte 3) Reinaldo Fortes Universidade Federal de Ouro Preto, UFOP Departamento de Ciência da Computação, DECOM Website: www.decom.ufop.br/reifortes
1. O que é a eficiência assintótica de um algoritmo. Explique com suas palavras.
Disciplina: Estrutura de Dados II Turma: 4EC/5CC Data: 13/11/15 Nota: Professor: Renato E. N. de Moraes Semestre: 2015-2 Valor: 0,0 pts Aluno: Lista de exercícios 04 1. O que é a eficiência assintótica
Análise de Algoritmos
Análise de Algoritmos Parte 3 Prof. Túlio Toffolo http://www.toffolo.com.br BCC202 Aula 06 Algoritmos e Estruturas de Dados I Como escolher o algoritmo mais adequado para uma situação? (continuação) Exercício
Medida do Tempo de Execução de um Programa. David Menotti Algoritmos e Estruturas de Dados II DInf UFPR
Medida do Tempo de Execução de um Programa David Menotti Algoritmos e Estruturas de Dados II DInf UFPR Classes de Comportamento Assintótico Se f é uma função de complexidade para um algoritmo F, então
Quicksort. David Menotti Algoritmos e Estruturas de Dados II DInf UFPR
Quicksort David Menotti Algoritmos e Estruturas de Dados II DInf UFPR Quicksort Proposto por Hoare em 1960 e publicado em 1962. É o algoritmo de ordenação interna mais rápido que se conhece para uma ampla
Classificação e Pesquisa Aula 6 Métodos de Ordenação: ShellSort e QuickSort. Prof. Esp. Pedro Luís Antonelli Anhanguera Educacional
Classificação e Pesquisa Aula 6 Métodos de Ordenação: ShellSort e QuickSort Prof. Esp. Pedro Luís Antonelli Anhanguera Educacional Plano de Ensino e Aprendizagem ( PEA) Algoritmo ShellSort Proposto por
Projeto e Análise de Algoritmos
Projeto e Análise de Algoritmos Aula 09 Algoritmos de Ordenação Edirlei Soares de Lima Ordenação Problema: Entrada: conjunto de itens a 1, a 2,..., a n ; Saída: conjunto de itens
BCC202 - Estrutura de Dados I
BCC202 - Estrutura de Dados I Aula 15: Ordenação: ShellSort Reinaldo Fortes Universidade Federal de Ouro Preto, UFOP Departamento de Computação, DECOM Website: www.decom.ufop.br/reifortes Email: [email protected]
Projeto e Análise de Algoritmos
Projeto e Análise de Algoritmos Aula 01 Complexidade de Algoritmos Edirlei Soares de Lima O que é um algoritmo? Um conjunto de instruções executáveis para resolver um problema (são
Análise de Algoritmos Estrutura de Dados II
Centro de Ciências Exatas, Naturais e de Saúde Departamento de Computação Análise de Algoritmos Estrutura de Dados II COM10078 - Estrutura de Dados II Prof. Marcelo Otone Aguiar [email protected]
Extra- Algoritmos de Ordenação
Extra- Algoritmos de Ordenação 1 Introdução Ordenar: processo de rearranjar um conjunto de objetos em uma ordem ascendente ou descendente. A ordenação visa facilitar a recuperação posterior de itens do
André Vignatti DINF- UFPR
Notação Assintótica: Ω, Θ André Vignatti DINF- UFPR Limitantes Inferiores Considere o seguinte trecho de código: void main () { /* trecho que le N da entrada padrao */ for (i = 0 ; i< N; i++) puzzle(i);
UNIVERSIDADE FEDERAL DO ESPÍRITO SANTO CENTRO UNIVERSITÁRIO NORTE DO ESPÍRITO SANTO
Disciplina: Estrutura de Dados II Turma: 4EC/5CC Data: 13/11/15 Nota: Professor: Renato E. N. de Moraes Semestre: 2015-2 Valor: 0,0 pts Aluno: Lista de exercícios 04 1. O que é a eficiência assintótica
INF 1620 P2-01/11/03 Questão 1 Nome:
INF 1620 P2-01/11/03 Questão 1 Considere a implementação de uma lista encadeada para armazenar as notas dos alunos de uma turma dada pelo tipo abaixo: struct lista { char nome[81]; int mat; float p1, p2,
Centro Federal de Educação Tecnológica de Minas Gerais Programa de Pós-Graduação em Modelagem Matemática e Computacional
Centro Federal de Educação Tecnológica de Minas Gerais Programa de Pós-Graduação em Modelagem Matemática e Computacional Disciplina: Algoritmos e Estruturas de Dados Professor: Flávio Cardeal Lista de
Linguagem C: Algoritmos de Ordenação
Introdução Prof. Paulo R. S. L. Coelho [email protected] Faculdade de Computação Universidade Federal de Uberlândia GEQ007 Organização Introdução 1 Introdução 2 3 Organização Introdução 1 Introdução 2
Estrutura de Dados. Carlos Eduardo Batista. Centro de Informática - UFPB
Estrutura de Dados Carlos Eduardo Batista Centro de Informática - UFPB [email protected] Listas e Filas Estruturas de Dados 2 Estrututuras de dados lineares Pilhas (stack) Estrutura de dados onde a inserção
Algoritmos de Ordenação: QuickSort
Algoritmos de Ordenação: QuickSort ACH2002 - Introdução à Ciência da Computação II Delano M. Beder Escola de Artes, Ciências e Humanidades (EACH) Universidade de São Paulo [email protected] 10/2008 Material
Capacitação em Linguagem C Parte 2
Capacitação em Linguagem C Parte 2 Andrey Souto Maior Giuseppe Portolese Universidade Estadual de Maringá - Centro de Tecnologia Departamento de Informática 22 de outubro de 2015 Sumário I Tipos abstratos
Análise de Algoritmos
Análise de Algoritmos Aula 04 Prof. Fernando Freitas Classes de Comportamento Assintótico Se f é uma função de complexidade para um algoritmo F, então O(f) é considerada a complexidade assintótica ou o
Medida do Tempo de Execução de um Programa
Medida do Tempo de Execução de um Programa Livro Projeto de Algoritmos Nívio Ziviani Capítulo 1 Seção 1.3.1 http://www2.dcc.ufmg.br/livros/algoritmos/ Comportamento Assintótico de Funções O parâmetro n
Programação II. Árvores Binárias (Binary Trees) Bruno Feijó Dept. de Informática, PUC-Rio
Programação II Árvores Binárias (Binary Trees) Bruno Feijó Dept. de Informática, PUC-Rio Árvores Dados organizados de maneira hierárquica Exemplos: arquivos em diretórios, subdivisão de espaço 2D em um
Análise de algoritmos. Parte I
Análise de algoritmos Parte I 1 Recursos usados por um algoritmo Uma vez que um procedimento está pronto/disponível, é importante determinar os recursos necessários para sua execução Tempo Memória Qual
Métodos de Ordenação Parte I
Estrutura de Dados II Métodos de Ordenação Parte I Prof a Márcio Bueno [email protected] / [email protected] Material baseado nos materiais da Prof a Ana Eliza e Prof. Robson Lins Rearranjar
Filas. Prof. Túlio Toffolo BCC202 Aula 12 Algoritmos e Estruturas de Dados I
Filas Prof. Túlio Toffolo http://www.toffolo.com.br BCC202 Aula 12 Algoritmos e Estruturas de Dados I O que é uma fila? 1 4 2 3 Fila 1 2 3 4 TAD Fila Tipo Abstrato de dados com a seguinte característica:
Métodos de Ordenação
Métodos de Ordenação Conceitos básicos sobre ordenação Ordenar corresponde ao processo de rearranjar um conjunto de objetos em uma ordem específica. Objetivo da ordenação: facilitar a recuperação posterior
INF 1010 Estruturas de Dados Avançadas
INF 1010 Estruturas de Dados Avançadas Complexidade de Algoritmos 1 Introdução Complexidade computacional Termo criado por Juris Hartmanis e Richard Stearns (1965) Relação entre o tamanho do problema e
Aula T19 BCC202 Pesquisa (Parte 1) Pesquisa Binária. Túlio Toffolo
Aula T19 BCC202 Pesquisa (Parte 1) Pesquisa Binária Túlio Toffolo www.decom.ufop.br/toffolo Pesquisa em Memória Primária n Introdução - Conceitos Básicos n Pesquisa Sequencial n Pesquisa Binária n Árvores
ESTRUTURAS DE DADOS prof. Alexandre César Muniz de Oliveira
ESTRUTURAS DE DADOS prof. Alexandre César Muniz de Oliveira 1. Introdução 2. Pilhas 3. Filas 4. Listas 5. Árvores 6. Grafos 7. Complexidade 8. Ordenação 9. Busca Sugestão bibliográfica: ESTRUTURAS DE DADOS
Aula 1. Teoria da Computação III
Aula 1 Teoria da Computação III Complexidade de Algoritmos Um problema pode ser resolvido através de diversos algoritmos; O fato de um algoritmo resolver um dado problema não significa que seja aceitável
Quantidade de memória necessária
Tempo de processamento Um algoritmo que realiza uma tarefa em 10 horas é melhor que outro que realiza em 10 dias Quantidade de memória necessária Um algoritmo que usa 1MB de memória RAM é melhor que outro
Matemática computacional: métodos numéricos, programação linear, otimização
Matemática computacional: métodos numéricos, programação linear, otimização Ricardo Terra rterrabh [at] gmail.com Ricardo Terra (rterrabh [at] gmail.com) Matemática computacional Fevereiro, 2013 1 / 46
BCC202 - Estrutura de Dados I
BCC202 - Estrutura de Dados I Aula 13: Ordenação: MergeSort Reinaldo Fortes Universidade Federal de Ouro Preto, UFOP Departamento de Computação, DECOM Website: www.decom.ufop.br/reifortes Email: [email protected]
REVISÃO DE PILHAS E FILAS. Vanessa Braganholo Estruturas de Dados e Seus Algoritmos
REVISÃO DE PILHAS E FILAS Vanessa Braganholo Estruturas de Dados e Seus Algoritmos PILHAS E FILAS São tipos especiais de listas com disciplina restrita de acesso Acesso Consulta Inserção Remoção Disciplina
Complexidade Assintótica de Programas Letícia Rodrigues Bueno
Complexidade Assintótica de Programas Letícia Rodrigues Bueno Análise de Algoritmos 1. Introdução; Análise de Algoritmos 1. Introdução; 2. Conceitos básicos; Análise de Algoritmos 1. Introdução; 2. Conceitos
ALGORITMOS DE ORDENAÇÃO
ALGORITMOS DE ORDENAÇÃO Prof. André Backes Conceitos básicos 2 Ordenação Ato de colocar um conjunto de dados em uma determinada ordem predefinida Fora de ordem 5, 2, 1, 3, 4 Ordenado 1, 2, 3, 4, 5 OU 5,
Elementos de Análise Assintótica
Elementos de Análise Assintótica Marcelo Keese Albertini Faculdade de Computação Universidade Federal de Uberlândia 23 de Março de 2018 Aula de hoje Nesta aula veremos: Elementos de Análise Assintótica
Aula 15: Pesquisa em Memória Primária. Bruno Hott Algoritmos e Estruturas de Dados I DECSI UFOP
Aula 15: Pesquisa em Memória Primária Bruno Hott Algoritmos e Estruturas de Dados I DECSI UFOP Pesquisa em Memória Primária Introdução - Conceitos Básicos Pesquisa Sequencial Pesquisa Binária Árvores de
1 a Lista de Exercícios
Universidade Federal de Ouro Preto Instituto de Ciências Exatas e Biológicas Programa de Pós-Graduação em Ciência da Computação Projeto e Análise de Algoritmos - 1 o semestre de 2010 Professor: David Menotti
Medida do Tempo de Execução de um Programa. David Menotti Algoritmos e Estruturas de Dados II DInf UFPR
Medida do Tempo de Execução de um Programa David Menotti Algoritmos e Estruturas de Dados II DInf UFPR Medida do Tempo de Execução de um Programa O projeto de algoritmos é fortemente influenciado pelo
ALGORITMOS AVANÇADOS UNIDADE I Análise de Algoritmo - Notação O. Luiz Leão
Luiz Leão [email protected] http://www.luizleao.com Conteúdo Programático 1.1 - Algoritmo 1.2 - Estrutura de Dados 1.2.1 - Revisão de Programas em C++ envolvendo Vetores, Matrizes, Ponteiros, Registros
Listas Encadeadas. David Menotti Algoritmos e Estruturas de Dados II DInf UFPR
Listas Encadeadas David Menotti Algoritmos e Estruturas de Dados II DInf UFPR Listas Encadeadas Características: Tamanho da lista não é pré-definido Cada elemento guarda quem é o próximo Elementos não
BCC202 - Estrutura de Dados I
BCC202 - Estrutura de Dados I Aula 14: Ordenação: QuickSort Reinaldo Fortes Universidade Federal de Ouro Preto, UFOP Departamento de Computação, DECOM Website: www.decom.ufop.br/reifortes Email: [email protected]
Linguagem C: Ordenação
Instituto de C Linguagem C: Ordenação Luis Martí Instituto de Computação Universidade Federal Fluminense [email protected] - http://lmarti.com Tópicos Principais Introdução Algoritmos de ordenação Ordenação
Complexidade de Algoritmos
Complexidade de Algoritmos Prof. Diego Buchinger [email protected] [email protected] Prof. Cristiano Damiani Vasconcellos [email protected] Funções de Complexidade Considere
Algoritmos e Estruturas de Dados I Aula 06 Custos de um algoritmo
Algoritmos e Estruturas de Dados I Aula 06 Custos de um algoritmo Prof. Jesús P. Mena-Chalco 1Q-2019 1 lista 3 7-2 6 NULL Node *Busca(int x, Node *lista) { while (lista!=null && lista->data!=x) lista =
Métodos de Classificação
Métodos de Classificação 261 Objetivos e Caracterizações O acesso a um conjunto de dados é facilitado se o mesmo está armazenado conforme uma certa ordem, baseada num critério conhecido. O objetivo básico
Ordenação: Heapsort. Algoritmos e Estruturas de Dados II
Ordenação: Heapsort Algoritmos e Estruturas de Dados II Introdução Possui o mesmo princípio de funcionamento da ordenação por seleção Selecione o menor item do vetor Troque-o pelo item da primeira posição
Análise de Algoritmos
Análise de Algoritmos Parte 1 Prof. Túlio Toffolo http://www.toffolo.com.br BCC202 Aula 04 Algoritmos e Estruturas de Dados I Qual a diferença entre um algoritmo e um programa? Como escolher o algoritmo
Algoritmos de Ordenação
Algoritmos de Ordenação! Problema: encontrar um número de telefone em uma lista telefônica! simplificado pelo fato dos nomes estarem em ordem alfabética! e se estivesse sem uma ordem?! Problema: busca
Análise de complexidade
Introdução Algoritmo: sequência de instruções necessárias para a resolução de um problema bem formulado (passíveis de implementação em computador) Estratégia: especificar (definir propriedades) arquitectura
Medida do Tempo de Execução de um Programa. Bruno Hott Algoritmos e Estruturas de Dados I DECSI UFOP
Medida do Tempo de Execução de um Programa Bruno Hott Algoritmos e Estruturas de Dados I DECSI UFOP Medida do Tempo de Execução de um Programa O projeto de algoritmos é fortemente influenciado pelo estudo
MAC121 ALGORITMOS E ESTRUTURAS DE DADOS I 2O. SEMESTRE DE 2017
PROVA 1 MAC121 ALGORITMOS E ESTRUTURAS DE DADOS I 2O. SEMESTRE DE 2017 Nome: Número USP: Instruções: (1 ) Esta prova é individual. (2 ) Não destaque as folhas deste caderno. (3 ) A prova consiste de 6
DAINF - Departamento de Informática
DAINF - Departamento de Informática Algoritmos 2 - Árvore binária de busca Prof. Alex Kutzke ( http://alex.kutzke.com.br/courses ) 30 de Novembro de 2015 Slides adaptados do material produzido pelo Prof.
LISTAS ENCADEADAS OU NÃO- SEQÜENCIAIS. Estrutura de Dados
LISTAS ENCADEADAS OU NÃO- SEQÜENCIAIS Listas Lineares Como visto anteriormente, as operações básicas para o nosso TAD Lista Linear são: FLVazia Vazia Retira Insere Imprime A implementação através de arrays
heapsort (int *x, int n) { int i, e, s, f, aux; /*fase de pré-processamento - cria heap inicial*/ for (i=1; i<n; i++) { e = x[i]; s = i; f = (s-1)/2;
![heapsort (int *x, int n) { int i, e, s, f, aux; /*fase de pré-processamento - cria heap inicial*/ for (i=1; i<n; i++) { e = x[i]; s = i; f = (s-1)/2;](/thumbs/82/86806582.jpg "heapsort (int *x, int n) { int i, e, s, f, aux; /*fase de pré-processamento - cria heap inicial*/ for (i=1; i<n; i++) { e = x[i]; s = i; f = (s-1)/2;")
heapsort (int *x, int n) { int i, e, s, f, aux; /*fase de pré-processamento - cria heap inicial*/ for (i=1; i0 && x[f]
Listas Lineares. Livro Projeto de Algoritmos Nívio Ziviani Capítulo 3 Seção 3.1
Listas Lineares Elerson R. S. Santos [email protected] Livro Projeto de Algoritmos Nívio Ziviani Capítulo 3 Seção 3.1 http://www2.dcc.ufmg.br/livros/algoritmos/ Listas Lineares Uma das formas mais simples
Árvores de Pesquisa. A árvore de pesquisa é uma estrutura de dados muito eficiente para armazenar informação.
Árvores de Pesquisa A árvore de pesquisa é uma estrutura de dados muito eficiente para armazenar informação. Particularmente adequada quando existe necessidade de considerar todos ou alguma combinação
Edital de Seleção 053/2016 PROPESP/UFAM. Prova de Conhecimento. Caderno de Questões
Edital de Seleção 053/2016 PROPESP/UFAM Prova de Conhecimento Caderno de Questões CANDIDATO: INSCRIÇÃO: Assinatura conforme identidade INSTRUÇÕES PARA O CANDIDATO: Verifique o seu nome e o número da sua
Área que visa determinar a complexidade (custo) de um algoritmo, com isso é possível:
Área que visa determinar a complexidade (custo) de um algoritmo, com isso é possível: Comparar algoritmos: existem algoritmos que resolvem o mesmo tipo de problema. Determinar se o algoritmo é ótimo :
INF111 Programação II Aulas 11, 12, 13 Ordenação
INF Programação II Aulas,, Ordenação Departamento de Informática UFV Ordenação A ordenação é o processo de organizar um conunto (vetor) de n obetos ou registros segundo uma determinada ordem crescente
HeapSort Filas de Prioridade Heap. David Menotti Algoritmos e Estruturas de Dados II DInf UFPR
HeapSort Filas de Prioridade Heap David Menotti Algoritmos e Estruturas de Dados II DInf UFPR Filas de Prioridades É uma estrutura de dados onde a chave de cada item reflete sua habilidade relativa de
Marcelo Keese Albertini Faculdade de Computação Universidade Federal de Uberlândia
Introdução à Análise de Algoritmos Marcelo Keese Albertini Faculdade de Computação Universidade Federal de Uberlândia Aula de hoje Nesta aula veremos: Sobre a disciplina Exemplo: ordenação Sobre a disciplina
HeapSort. Estrutura de Dados II Jairo Francisco de Souza
HeapSort Estrutura de Dados II Jairo Francisco de Souza HeapSort Algoritmo criado por John Williams (1964) Complexidade O(NlogN) no pior e médio caso Mesmo tendo a mesma complexidade no caso médio que
É interessante comparar algoritmos para valores grandes de n. Para valores pequenos de n, mesmo um algoritmo ineficiente não custa muito para ser
É interessante comparar algoritmos para valores grandes de n. Para valores pequenos de n, mesmo um algoritmo ineficiente não custa muito para ser executado 1 Fazendo estimativas e simplificações... O número
Estrutura de Dados. Algoritmos de Ordenação. Prof. Othon M. N. Batista Mestre em Informática
Estrutura de Dados Algoritmos de Ordenação Prof. Othon M. N. Batista Mestre em Informática Roteiro Introdução Ordenação por Inserção Insertion Sort Ordenação por Seleção Selection Sort Ordenação por Bolha
ALGORITMOS E ESTRUTURAS DE DADOS CES-11 Prof. Paulo André Castro Sala 110 Prédio da Computação IECE - ITA
ALGORITMOS E ESTRUTURAS DE DADOS CES-11 Prof. Paulo André Castro [email protected] Sala 110 Prédio da Computação www.comp.ita.br/~pauloac IECE - ITA MÉTODOS MAIS EFICIENTES QUE O(N 2 ) Método Quicksort Método