Algoritmos e Estrutura de Dados Ricardo Terra rterrabh [at] gmail.com Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 1 / 136
CV Nome: Ricardo Terra Email: rterrabh [at] gmail.com www: ricardoterra.com.br Twitter: rterrabh Lattes: lattes.cnpq.br/ 0162081093970868 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, 2013 2 / 136
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, 2013 3 / 136
Introdução Conteúdo Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 4 / 136
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, 2013 5 / 136
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, 2013 6 / 136
Estrutura de Dados Listas Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 7 / 136
Estrutura de Dados Listas Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 8 / 136
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)); 12 13 retira(l, D ); 14 retira(l, I ); 15 retira(l, X ); 16 retira(l, O ); 17 printf("tamanho: %d\n", tamanho(l)); 18 19 retira(l, Z ); 20 printf("tamanho: %d\n", tamanho(l)); 21 22 imprime(l); 23 24 /* limpar(l); */ 25 printf("tamanho: %d\n", tamanho(l)); 26 27 return 0; 28 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 9 / 136
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 }; 8 10 9 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, 2013 10 / 136
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, 2013 11 / 136
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, 2013 12 / 136
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, 2013 13 / 136
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, 2013 14 / 136
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, 2013 15 / 136
Estrutura de Dados Listas Função retira 45 int retira(tlista* l, char c){ 46 TCelula *aux, *rastro; 47 48 if (!vazia(l)) { /* Se a lista nao for vazia */ 49 rastro = l->primeiro; 50 aux = l->primeiro->prox; 51 52 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, 2013 16 / 136
Estrutura de Dados Filas Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 17 / 136
Estrutura de Dados Filas Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 18 / 136
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 ); 11 12 printf("desenfileirou: %c\n", desenfileira(f)); 13 printf("desenfileirou: %c\n", desenfileira(f)); 14 printf("desenfileirou: %c\n", desenfileira(f)); 15 16 if (!vazia(f)){ 17 printf("desenfileirou: %c\n", desenfileira(f)); 18 } 19 20 enfileira(f, D ); 21 enfileira(f, E ); 22 23 while (!vazia(f)){ 24 printf("desenfileirou: %c\n", desenfileira(f)); 25 } 26 printf("vazia: %s\n", (vazia(f))? "Sim" : "Nao"); 27 28 return 0; 29 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 19 / 136
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 }; 8 10 9 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, 2013 20 / 136
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, 2013 21 / 136
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, 2013 22 / 136
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, 2013 23 / 136
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, 2013 24 / 136
Estrutura de Dados Pilhas Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 25 / 136
Estrutura de Dados Pilhas Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 26 / 136
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); 11 12 printf("desempilhou: %c\n", desempilha(p)); 13 printf("desempilhou: %c\n", desempilha(p)); 14 printf("desempilhou: %c\n", desempilha(p)); 15 16 if (!vazia(p)){ 17 printf("desempilhou: %c\n", desempilha(p)); 18 } 19 20 empilha(p, D ); 21 empilha(p, E ); printf("tamanho: %d\n",p->tamanho); 22 23 while (!vazia(p)){ 24 printf("desempilhou: %c\n", desempilha(p)); 25 } 26 printf("vazia: %s\n", (vazia(p))? "Sim" : "Nao"); 27 28 return 0; 29 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 27 / 136
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 }; 8 10 9 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, 2013 28 / 136
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, 2013 29 / 136
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, 2013 30 / 136
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, 2013 31 / 136
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, 2013 32 / 136
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, 2013 33 / 136
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, 2013 34 / 136
Análise de Algoritmos Complexidade Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 35 / 136
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, 2013 36 / 136
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, 2013 37 / 136
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, 2013 37 / 136
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, 2013 38 / 136
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, 2013 39 / 136
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, 2013 39 / 136
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, 2013 40 / 136
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, 2013 41 / 136
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, 2013 42 / 136
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, 2013 42 / 136
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, 2013 42 / 136
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, 2013 43 / 136
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, 2013 44 / 136
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, 2013 44 / 136
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, 2013 44 / 136
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, 2013 44 / 136
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 + 1 2 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 44 / 136
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, 2013 45 / 136
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, 2013 45 / 136
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, 2013 45 / 136
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, 2013 46 / 136
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, 2013 46 / 136
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, 2013 46 / 136
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, 2013 46 / 136
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, 2013 46 / 136
Análise de Algoritmos Comportamento Assintótico Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 47 / 136
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, 2013 48 / 136
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, 2013 49 / 136
y Análise de Algoritmos Comportamento Assintótico Exemplo Sejam: g(n) = (n + 1) 2 f (n) = n 2 15 10 (n+1)^2 n^2 4(n^2) 5 0-0.5 0.0 0.5 1.0 1.5 2.0 x Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 50 / 136
y Análise de Algoritmos Comportamento Assintótico Exemplo Sejam: g(n) = (n + 1) 2 f (n) = n 2 15 10 5 (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) 2-0.5 0.0 0.5 1.0 1.5 2.0 x para c = 1 e n 0 = 0 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 50 / 136
y Análise de Algoritmos Comportamento Assintótico Exemplo Sejam: f (n) = n g(n) = n 2 4 3 2 n -n^2 1 0-0.5 0.0 0.5 1.0 1.5 2.0 x Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 51 / 136
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 = 0 1 0-0.5 0.0 0.5 1.0 1.5 2.0 x Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 51 / 136
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 = 0 1 0-0.5 0.0 0.5 1.0 1.5 2.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, 2013 51 / 136
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, 2013 52 / 136
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, 2013 53 / 136
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, 2013 53 / 136
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, 2013 53 / 136
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, 2013 53 / 136
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, 2013 54 / 136
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, 2013 54 / 136
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, 2013 54 / 136
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, 2013 54 / 136
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, 2013 55 / 136
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, 2013 56 / 136
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, 2013 56 / 136
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, 2013 56 / 136
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, 2013 57 / 136
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, 2013 58 / 136
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, 2013 58 / 136
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, 2013 59 / 136
Análise de Algoritmos Comportamento Assintótico Classes de Comportamento Assintótico 60 y 40 20 f(n) = 1 lg(n) n n*lg(n) n^2 n^3 2^n n! 0 1 2 3 4 x Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 60 / 136
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, 2013 61 / 136
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, 2013 62 / 136
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, 2013 63 / 136
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, 2013 64 / 136
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, 2013 65 / 136
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, 2013 66 / 136
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, 2013 67 / 136
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, 2013 68 / 136
Análise de Algoritmos Comportamento Assintótico Classes de Comportamento Assintótico Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 69 / 136
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, 2013 70 / 136
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, 2013 70 / 136
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, 2013 71 / 136
Métodos de Ordenação Conceitualização Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 72 / 136
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, 2013 73 / 136
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, 2013 74 / 136
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 1000 800, 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, 2013 75 / 136
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, 2013 76 / 136
Métodos de Ordenação SelectionSort (Seleção) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 77 / 136
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, 2013 78 / 136
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, 2013 79 / 136
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, 2013 79 / 136
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, 2013 79 / 136
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, 2013 80 / 136
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, 2013 80 / 136
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, 2013 80 / 136
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, 2013 81 / 136
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 } 15 16 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); 21 22 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, 2013 82 / 136
Métodos de Ordenação BubbleSort (Bolha) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 83 / 136
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, 2013 84 / 136
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, 2013 85 / 136
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 } 13 14 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); 19 20 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, 2013 86 / 136
Métodos de Ordenação InsertionSort (Inserção) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 87 / 136
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, 2013 88 / 136
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, 2013 89 / 136
Métodos de Ordenação InsertionSort (Inserção) Análise por número de comparações C(n) Melhor caso : C(n) = (1 + 1 + 1 +... + 1) = n 1 = O(n) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 89 / 136
Métodos de Ordenação InsertionSort (Inserção) Análise por número de comparações C(n) Melhor caso : C(n) = (1 + 1 + 1 +... + 1) = n 1 = O(n) Pior caso : C(n) = (2 + 3 + 4 +... + n) = n2 2 + n 2 1 = O(n2 ) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 89 / 136
Métodos de Ordenação InsertionSort (Inserção) Análise por número de comparações C(n) Melhor caso : C(n) = (1 + 1 + 1 +... + 1) = n 1 = O(n) Pior caso : C(n) = (2 + 3 + 4 +... + n) = n2 2 + n 2 1 = O(n2 ) Caso medio : C(n) = n2 4 + 3n 4 1 = O(n2 ) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 89 / 136
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, 2013 90 / 136
Métodos de Ordenação InsertionSort (Inserção) Análise por número de movimentações M(n) Melhor caso : M(n) = (3 + 3 + 3 +... + 3) = 3(n 1) = O(n) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 90 / 136
Métodos de Ordenação InsertionSort (Inserção) Análise por número de movimentações M(n) Melhor caso : M(n) = (3 + 3 + 3 +... + 3) = 3(n 1) = O(n) Pior caso : M(n) = (4 + 5 + 6 +... + n + 2) = n2 2 + 5n 2 3 = O(n2 ) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 90 / 136
Métodos de Ordenação InsertionSort (Inserção) Análise por número de movimentações M(n) Melhor caso : M(n) = (3 + 3 + 3 +... + 3) = 3(n 1) = O(n) Pior caso : M(n) = (4 + 5 + 6 +... + n + 2) = n2 2 + 5n 2 3 = O(n2 ) Caso medio : C(n) = n2 4 + 11n 4 3 = O(n2 ) Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 90 / 136
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, 2013 91 / 136
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, 2013 91 / 136
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 } 14 15 16 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); 21 22 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, 2013 92 / 136
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, 2013 93 / 136
Métodos de Ordenação ShellSort Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 94 / 136
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, 2013 95 / 136
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, 2013 96 / 136
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, 2013 97 / 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 } 20 21 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, 2013 98 / 136
Métodos de Ordenação QuickSort Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 99 / 136
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, 2013 100 / 136
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, 2013 101 / 136
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, 2013 102 / 136
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, 2013 103 / 136
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, 2013 104 / 136
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, 2013 105 / 136
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, 2013 106 / 136
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 } 19 20 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, 2013 107 / 136
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, 2013 108 / 136
Pesquisa em Memória Primária Pesquisa Sequencial Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 109 / 136
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 + 1 2 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 110 / 136
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, 2013 111 / 136
Pesquisa em Memória Primária Pesquisa Binária Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 112 / 136
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): 1 1 2 3 4 5 6 7 8 9 10 11 12 13 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 113 / 136
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): 1 1 2 3 4 5 6 7 8 9 10 11 12 13 2 8 9 10 11 12 13 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 113 / 136
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): 1 1 2 3 4 5 6 7 8 9 10 11 12 13 2 8 9 10 11 12 13 3 8 9 10 Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 113 / 136
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): 1 1 2 3 4 5 6 7 8 9 10 11 12 13 2 8 9 10 11 12 13 3 8 9 10 Problema resolvido? Vamos manter sempre ordenado. Resolvido o problema? Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 113 / 136
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, 2013 114 / 136
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, 2013 114 / 136
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, 2013 114 / 136
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, 2013 114 / 136
Pesquisa em Memória Primária Árvores de Pesquisa Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 115 / 136
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, 2013 116 / 136
Pesquisa em Memória Primária Árvores Binárias sem Balanceamento Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 117 / 136
Á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, 2013 118 / 136
Á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, 2013 119 / 136
Á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 } 11 12 central(arvore); printf("\n"); 13 preordem(arvore); printf("\n"); 14 posordem(arvore); printf("\n"); 15 16 retira(&arvore, J ); 17 retira(&arvore, H ); 18 retira(&arvore, B ); 19 retira(&arvore, N ); 20 21 central(arvore); printf("\n"); 22 preordem(arvore); printf("\n"); 23 24 printf("tem A? %s\n", (pesquisa(arvore, A ))? "S" : "N" ); 25 printf("tem B? %s\n", (pesquisa(arvore, B ))? "S" : "N" ); 26 27 return 0; 28 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 120 / 136
Á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 } 11 12 central(arvore); printf("\n"); 13 preordem(arvore); printf("\n"); 14 posordem(arvore); printf("\n"); 15 16 retira(&arvore, J ); 17 retira(&arvore, H ); 18 retira(&arvore, B ); 19 retira(&arvore, N ); 20 21 central(arvore); printf("\n"); 22 preordem(arvore); printf("\n"); 23 24 printf("tem A? %s\n", (pesquisa(arvore, A ))? "S" : "N" ); 25 printf("tem B? %s\n", (pesquisa(arvore, B ))? "S" : "N" ); 26 27 return 0; 28 } Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 120 / 136
Á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, 2013 121 / 136
Á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, 2013 122 / 136
Á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, 2013 123 / 136
Á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, 2013 124 / 136
Á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, 2013 125 / 136
Á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, 2013 126 / 136
Á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, 2013 127 / 136
Á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, 2013 128 / 136
Á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, 2013 129 / 136
Á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, 2013 130 / 136
Á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, 2013 131 / 136
Á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, 2013 132 / 136
Á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, 2013 133 / 136
Pesquisa em Memória Primária Árvores Binárias com Balanceamento Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 134 / 136
Á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, 2013 135 / 136
Referências Thomas Cormen. Introduction to algorithms. MIT Press, 3 edition, 2009. Paulo Feofiloff. Algoritmos em Linguagem C. Elsevier, 2009. Nivio Ziviani. Projeto de algoritmos com implementações em Pascal e C. Cengage Learning, 3 edition, 2010. Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 136 / 136