O documento apresenta o currículo de Ricardo Terra, professor de algoritmos e estruturas de dados. Ele descreve sua formação acadêmica e profissional, incluindo um PhD e pós-doutorado em ciência da computação, além de experiência como professor em diversas instituições de ensino superior. O documento também fornece seus contatos para possíveis oportunidades de colaboraçã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, 2013 1 / 136
2. 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
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, 2013 3 / 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, 2013 5 / 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, 2013 6 / 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 };
8
9 typedef struct Celula TCelula;
10
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
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, 2013 11 / 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, 2013 12 / 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, 2013 13 / 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, 2013 14 / 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 = %cn", aux->info);
43 }
44 }
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 15 / 136
16. 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
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 };
8
9 typedef struct Celula TCelula;
10
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
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, 2013 21 / 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, 2013 22 / 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, 2013 23 / 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, 2013 24 / 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 };
8
9 typedef struct Celula TCelula;
10
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
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, 2013 29 / 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, 2013 30 / 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, 2013 31 / 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, 2013 32 / 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, 2013 33 / 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, 2013 34 / 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, 2013 36 / 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, 2013 37 / 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, 2013 37 / 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, 2013 38 / 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, 2013 39 / 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, 2013 39 / 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, 2013 40 / 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, 2013 41 / 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, 2013 42 / 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, 2013 42 / 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, 2013 42 / 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, 2013 43 / 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, 2013 44 / 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, 2013 44 / 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, 2013 44 / 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, 2013 44 / 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
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 44 / 136
Caso m´edio: f(n) =
n + 1
2
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, 2013 45 / 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, 2013 45 / 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, 2013 45 / 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, 2013 46 / 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, 2013 46 / 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, 2013 46 / 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, 2013 46 / 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)
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 46 / 136
Caso m´edio: f(n) =
3n − 3
2
61. Análise de Algoritmos
Comportamento Assintótico
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 47 / 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, 2013 48 / 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 n0 tais que,
para n ≥ n0, temos |g(n)| ≤ c x |f(n)|
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 49 / 136
64. Análise de Algoritmos – Comportamento Assintótico
Exemplo
Sejam:
g(n) = (n + 1)
2
f(n) = n2
0
5
10
15
-0.5 0.0 0.5 1.0 1.5 2.0
x
y
(n+1)^2
n^2
4(n^2)
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 50 / 136
65. Análise de Algoritmos – Comportamento Assintótico
Exemplo
Sejam:
g(n) = (n + 1)
2
f(n) = n2
0
5
10
15
-0.5 0.0 0.5 1.0 1.5 2.0
x
y
(n+1)^2
n^2
4(n^2)
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 50 / 136
As funções g(n) e f(n) dominam
assintoticamente uma a outra, já
que
|(n + 1)2
| ≤ c|n2
|
para c = 4 e n0 = 1
|n2
| ≤ c|(n + 1)2
|
para c = 1 e n0 = 0
66. Análise de Algoritmos – Comportamento Assintótico
Exemplo
Sejam:
f(n) = n
g(n) = −n2
0
1
2
3
4
-0.5 0.0 0.5 1.0 1.5 2.0
x
y
n
|-n^2|
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 51 / 136
67. Análise de Algoritmos – Comportamento Assintótico
Exemplo
Sejam:
f(n) = n
g(n) = −n2
0
1
2
3
4
-0.5 0.0 0.5 1.0 1.5 2.0
x
y
n
|-n^2|
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 51 / 136
A função g(n) domina
assintoticamente f(n), já que
|n| ≤ c| − n2
|
para c = 1 e n0 = 0
68. Análise de Algoritmos – Comportamento Assintótico
Exemplo
Sejam:
f(n) = n
g(n) = −n2
0
1
2
3
4
-0.5 0.0 0.5 1.0 1.5 2.0
x
y
n
|-n^2|
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 51 / 136
A função g(n) domina
assintoticamente f(n), já que
|n| ≤ c| − n2
|
para c = 1 e n0 = 0
No entanto, a função f(n) não
domina assintoticamente g(n), já
que
| − n2
| > c x |n|
para todo n > c e n > 1
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 n0 tais que |f(n)| ≤ c x |g(n)|, para todo n ≥ n0
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 52 / 136
70. Análise de Algoritmos – Comportamento Assintótico
Exemplo
Seja f(n) = (n + 1)2
Pergunta-se:
f(n) é O(n2
)?
f(n) é O(n3
)?
f(n) é O(n4
)?
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 53 / 136
71. Análise de Algoritmos – Comportamento Assintótico
Exemplo
Seja f(n) = (n + 1)2
Pergunta-se:
f(n) é O(n2
)? Sim, assumindo c = 4 e n0 = 1
f(n) é O(n3
)?
f(n) é O(n4
)?
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 53 / 136
72. Análise de Algoritmos – Comportamento Assintótico
Exemplo
Seja f(n) = (n + 1)2
Pergunta-se:
f(n) é O(n2
)? Sim, assumindo c = 4 e n0 = 1
f(n) é O(n3
)? Sim
f(n) é O(n4
)?
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 53 / 136
73. Análise de Algoritmos – Comportamento Assintótico
Exemplo
Seja f(n) = (n + 1)2
Pergunta-se:
f(n) é O(n2
)? Sim, assumindo c = 4 e n0 = 1
f(n) é O(n3
)? Sim
f(n) é O(n4
)? Sim
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 53 / 136
74. Análise de Algoritmos – Comportamento Assintótico
Exemplo
Seja f(n) = 3n3 + 2n2 + n
Pergunta-se:
f(n) é O(n2
)?
f(n) é O(n3
)?
f(n) é O(n4
)?
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 54 / 136
75. Análise de Algoritmos – Comportamento Assintótico
Exemplo
Seja f(n) = 3n3 + 2n2 + n
Pergunta-se:
f(n) é O(n2
)? Não
f(n) é O(n3
)?
f(n) é O(n4
)?
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 54 / 136
76. Análise de Algoritmos – Comportamento Assintótico
Exemplo
Seja f(n) = 3n3 + 2n2 + n
Pergunta-se:
f(n) é O(n2
)? Não
f(n) é O(n3
)? Sim, assumindo c = 6 e n0 = 0
f(n) é O(n4
)?
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 54 / 136
77. Análise de Algoritmos – Comportamento Assintótico
Exemplo
Seja f(n) = 3n3 + 2n2 + n
Pergunta-se:
f(n) é O(n2
)? Não
f(n) é O(n3
)? Sim, assumindo c = 6 e n0 = 0
f(n) é O(n4
)? Sim
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 54 / 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 n0 tais que |f(n)| ≥ c x |g(n)|, para todo n ≥ n0
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 55 / 136
79. Análise de Algoritmos – Comportamento Assintótico
Exemplo
Seja f(n) = 3n3 + 2n2
Pergunta-se:
f(n) é Ω(n3
)?
f(n) é Ω(n2
)?
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 56 / 136
80. Análise de Algoritmos – Comportamento Assintótico
Exemplo
Seja f(n) = 3n3 + 2n2
Pergunta-se:
f(n) é Ω(n3
)? Sim, assumindo c = 1 e n0 = 0
f(n) é Ω(n2
)?
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 56 / 136
81. Análise de Algoritmos – Comportamento Assintótico
Exemplo
Seja f(n) = 3n3 + 2n2
Pergunta-se:
f(n) é Ω(n3
)? Sim, assumindo c = 1 e n0 = 0
f(n) é Ω(n2
)? Sim
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 56 / 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
c1, c2 e n0 tais que 0 ≤ c1 x g(n) ≤ f(n) ≤ c2 x |g(n)|, para
todo n ≥ n0
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 57 / 136
83. Análise de Algoritmos – Comportamento Assintótico
Exemplo
Seja f(n) = n2
3 − 2n
Pergunta-se:
f(n) é Θ(n2
)?
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 58 / 136
84. Análise de Algoritmos – Comportamento Assintótico
Exemplo
Seja f(n) = n2
3 − 2n
Pergunta-se:
f(n) é Θ(n2
)? Sim, assumindo c1 = 1
21 , c2 = 1
3 e m = 7
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 58 / 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(n2): complexidade quadrática
f(n) = O(n3): complexidade cúbica
f(n) = O(2n): complexidade exponencial
f(n) = O(n!): complexidade fatorial
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 59 / 136
86. Análise de Algoritmos – Comportamento Assintótico
Classes de Comportamento Assintótico
0
20
40
60
1 2 3 4
x
y
f(n) =
1
lg(n)
n
n*lg(n)
n^2
n^3
2^n
n!
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 60 / 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, 2013 61 / 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, 2013 62 / 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, 2013 63 / 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, 2013 64 / 136
91. Análise de Algoritmos – Comportamento Assintótico
Complexidade quadrática f(n) = O(n2)
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
92. Análise de Algoritmos – Comportamento Assintótico
Complexidade cúbica f(n) = O(n3)
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
93. Análise de Algoritmos – Comportamento Assintótico
Complexidade exponencial f(n) = O(2n)
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
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 2n
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
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, 2013 69 / 136
96. Análise de Algoritmos – Comportamento Assintótico
Exercício
Seja um algoritmo A, de complexidade de tempo O(n5), e um
algoritmo B, de complexidade de tempo O(2n), 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
97. Análise de Algoritmos – Comportamento Assintótico
Exercício
Seja um algoritmo A, de complexidade de tempo O(n5), e um
algoritmo B, de complexidade de tempo O(2n), 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: n5 é O(2n), para c = 1 e n0 = 23
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 70 / 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, 2013 71 / 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, 2013 73 / 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, 2013 74 / 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
1000
,
Carlos
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
103. Métodos de Ordenação – Conceitualização
Métodos Simples:
SelectionSort (Seleção), BubbleSort (Bolha), InsertionSort (Inserção)
internos
O(n2
)
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
104. Métodos de Ordenação
SelectionSort (Seleção)
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 77 / 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, 2013 78 / 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, 2013 79 / 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, 2013 79 / 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, 2013 79 / 136
109. Métodos de Ordenação – SelectionSort (Seleção)
Análise por número de movimentações – M(n)
M(n) =
n−1
i=1
3
...
M(n) =
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 80 / 136
110. Métodos de Ordenação – SelectionSort (Seleção)
Análise por número de movimentações – M(n)
M(n) =
n−1
i=1
3
...
M(n) = 3(n − 1) = O( )
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 80 / 136
111. Métodos de Ordenação – SelectionSort (Seleção)
Análise por número de movimentações – M(n)
M(n) =
n−1
i=1
3
...
M(n) = 3(n − 1) = O(n)
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 80 / 136
112. Métodos de Ordenação – SelectionSort (Seleção)
SelectionSort — Resumo
Ordenação interna
C(n) = O(n2)
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
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 }
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("%dt", 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
114. Métodos de Ordenação
BubbleSort (Bolha)
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 83 / 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, 2013 84 / 136
116. Métodos de Ordenação – BubbleSort (Bolha)
BubbleSort — Resumo
Ordenação interna
C(n) = O(n2)
M(n) = O(n2)
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
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 }
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("%dt", 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
118. Métodos de Ordenação
InsertionSort (Inserção)
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 87 / 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, 2013 88 / 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, 2013 89 / 136
121. 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
122. 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
123. 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
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, 2013 90 / 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 + 3 + 3 + ... + 3) = 3(n − 1) = O(n)
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 90 / 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 + 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
127. 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
128. Métodos de Ordenação – InsertionSort (Inserção)
InsertionSort — Resumo
Ordenação interna
C(n) = O(n2), mas
M(n) = O(n2), 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
129. Métodos de Ordenação – InsertionSort (Inserção)
InsertionSort — Resumo
Ordenação interna
C(n) = O(n2), mas C(n) = Ω(n)
M(n) = O(n2), 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
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 }
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("%dt", 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
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, 2013 93 / 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, 2013 95 / 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
C1(n) = O(n1.25
)
C2(n) = O(n lg(n))
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 96 / 136
135. Métodos de Ordenação – ShellSort
ShellSort — Resumo
Ordenação interna
C1(n) = O(n1.25)
C2(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
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
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, 2013 100 / 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, 2013 101 / 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, 2013 102 / 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, 2013 103 / 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(n2) é evitado
Melhor caso : C(n) = 2C(
n
2
) + n − 1 = n lg(n) − n + 1 = O(n lg(n))
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
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(n2)
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
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, 2013 106 / 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 }
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 }
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("%dt", v[i]);
9 }
10 printf("n");
11 return 0;
12 }
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 107 / 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, 2013 108 / 136
147. Pesquisa em Memória Primária
Pesquisa Sequencial
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 109 / 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
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 110 / 136
Caso m´edio: f(n) =
n + 1
2
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, 2013 111 / 136
150. Pesquisa em Memória Primária
Pesquisa Binária
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 112 / 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):
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
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):
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
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):
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
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):
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
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, 2013 114 / 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, 2013 114 / 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 TAD1
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
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 TAD1
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
159. Pesquisa em Memória Primária
Árvores de Pesquisa
Ricardo Terra (rterrabh [at] gmail.com) Algoritmos e Estrutura de Dados Outubro, 2013 115 / 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, 2013 116 / 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, 2013 117 / 136
162. Árvores de Pesquisa – Árvores Binárias sem Balanceamento
Conceitos
Célula = Nó (ou nodo)
1o 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
Nível 0
Nível 1
.
.
.
163. Árvores de Pesquisa – Árvores Binárias sem Balanceamento
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
Nível 0
Nível 1
.
.
.
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 }
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? %sn", (pesquisa(arvore,’A’)) ? "S" : "N" );
25 printf("Tem B? %sn", (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
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 }
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? %sn", (pesquisa(arvore,’A’)) ? "S" : "N" );
25 printf("Tem B? %sn", (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
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, 2013 121 / 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, 2013 122 / 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, 2013 123 / 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, 2013 124 / 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, 2013 125 / 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, 2013 126 / 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, 2013 127 / 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, 2013 128 / 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, 2013 129 / 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, 2013 130 / 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, 2013 131 / 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, 2013 132 / 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, 2013 133 / 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, 2013 134 / 136
180. Árvores de Pesquisa – Árvores Binárias com Balanceamento
Árvore Balanceada
Árvore não Balanceada
Definição
Popularmente conhecida como
Árvore AVL
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
181. 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