Apostila Algoritmos e Estrutura de Dados (AEDS)

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 )
Proﬁssional : DBA Eng. (1 ano ), Synos (2 anos ), Stefanini (1 ano )

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

Introdução
Conteúdo

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

2. Estrutura de Dados – Conteúdo
1 Introdução 3
Listas 7
Filas 17
Pilhas 25

Estrutura de Dados
Listas

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: %dn", tamanho(l));
12
13 retira(l,’D’);
14 retira(l,’I’);
15 retira(l,’X’);
16 retira(l,’O’);
18
19 retira(l,’Z’);
21
22 imprime(l);
23
24 /* limpar(l); */
26
27 return 0;
28 }

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;

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 }

Função vazia
22 int vazia(TLista *l){
23 return (l->primeiro == l->ultimo);
24 }

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 }

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 }

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 }

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 }

Estrutura de Dados
Filas

Estrutura de Dados – Filas

2 TFila* f;
3 f = inicializa();
4 printf("Vazia: %sn", (vazia(f)) ? "Sim" : "Nao");
5
6 enfileira(f,’A’);
8
9 enfileira(f,’B’);
10 enfileira(f,’C’);
11
12 printf("Desenfileirou: %cn", desenfileira(f));
15
16 if (!vazia(f)){
18 }
19
20 enfileira(f,’D’);
21 enfileira(f,’E’);
22
23 while (!vazia(f)){
25 }
27
28 return 0;
29 }

Estruturas TCelula e TFila
1 #include<stdio.h>
3
4 struct Celula {
5 char info;
7 };
8
10
11 typedef struct {
12 TCelula *frente;
13 TCelula *tras;
14 } TFila;

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 }

Função vazia
22 int vazia(TFila* f){
23 return (f->frente == f->tras);
24 }

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 }

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 }

Estrutura de Dados
Pilhas

Estrutura de Dados – Pilhas

2 TPilha* p;
3 p = inicializa();
4 printf("Vazia: %sn", (vazia(p)) ? "Sim" : "Nao");
5
6 empilha(p,’A’); printf("Tamanho: %dn",p->tamanho);
8
9 empilha(p,’B’);
10 empilha(p,’C’); printf("Tamanho: %dn",p->tamanho);
11
12 printf("Desempilhou: %cn", desempilha(p));
15
16 if (!vazia(p)){
18 }
19
20 empilha(p,’D’);
21 empilha(p,’E’); printf("Tamanho: %dn",p->tamanho);
22
23 while (!vazia(p)){
25 }
27
28 return 0;
29 }

Estruturas TCelula e TPilha
1 #include<stdio.h>
3
4 struct Celula {
5 char info;
7 };
8
10
11 typedef struct {
12 TCelula *fundo;
13 TCelula *topo;
14 int tamanho;
15 } TPilha;

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 }

Função vazia
24 int vazia(TPilha* p){
25 return (p->topo == p->fundo);
26 }

Função tamanho
27 int tamanho(TPilha* p){
28 return p->tamanho;
29 }

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 }

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 }

3. Análise de Algoritmos – Conteúdo
1 Introdução 3
Complexidade 35
Comportamento Assintótico 47

Análise de Algoritmos
Complexidade

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”

Exemplo Motivador: Ordenação
Pergunta-se
1 Como seria um algoritmo para ordenar um arranjo?

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?

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 }

Exemplo Motivador: Achar o maior valor
Pergunta-se
1 Como seria um algoritmo para encontrar o maior valor de
um arranjo?

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?

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 }

Medir o custo de execução
Deﬁne-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

2 int i;
3 int maior = v[0];
4
5 for (i=1; i<tam; i++){
7 maior = v[i];
8 }
9 }
10 return maior;
11 }

2 int i;
3 int maior = v[0];
4
5 for (i=1; i<tam; i++){
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.

2 int i;
3 int maior = v[0];
4
5 for (i=1; i<tam; i++){
7 maior = v[i];
8 }
9 }
10 return maior;
11 }
f(n) = n − 1

Algoritmo ótimo
Quando o custo de um algoritmo é igual ao menor custo
possível, podemos aﬁrmar que o algoritmo é ótimo
Pergunta-se
O algoritmo Max é ótimo?

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 }

Pesquisa sequencial
2 int i;
3 for (i=0; i<tam; i++){
4 if ( v[i] == x ){
5 return i;
6 }
7 }
8 return -1;
9 }
elementos de v consultados, se v contiver n elementos

Pesquisa sequencial
2 int i;
3 for (i=0; i<tam; i++){
4 if ( v[i] == x ){
5 return i;
6 }
7 }
8 return -1;
9 }
Melhor caso: f(n) = 1

Pesquisa sequencial
2 int i;
3 for (i=0; i<tam; i++){
4 if ( v[i] == x ){
5 return i;
6 }
7 }
8 return -1;
9 }
Pior caso: f(n) = n

Pesquisa sequencial
2 int i;
3 for (i=0; i<tam; i++){
4 if ( v[i] == x ){
5 return i;
6 }
7 }
8 return -1;
9 }
Pior caso: f(n) = n
Caso m´edio: f(n) =
n + 1
2

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 }

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 }

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 }
f(n) = 2(n − 1)

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 }

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 }
elementos de v consultados, se v contiver n elementos.

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 }
Melhor caso: f(n) = n − 1

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 }
Pior caso: f(n) = 2(n − 1)

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 }
Pior caso: f(n) = 2(n − 1)
3n − 3
2

Análise de Algoritmos
Comportamento Assintótico

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

Deﬁniçã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)|

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)

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)
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

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|

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|
A função g(n) domina
assintoticamente f(n), já que
|n| ≤ c| − n2
|
para c = 1 e n0 = 0

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|
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

Deﬁniçã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

Exemplo
Seja f(n) = (n + 1)2
Pergunta-se:
f(n) é O(n2
)?
f(n) é O(n3
)?
f(n) é O(n4
)?

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
)?

Exemplo
Seja f(n) = (n + 1)2
Pergunta-se:
f(n) é O(n2
f(n) é O(n3
)? Sim
f(n) é O(n4
)?

Exemplo
Seja f(n) = (n + 1)2
Pergunta-se:
f(n) é O(n2
f(n) é O(n3
)? Sim
f(n) é O(n4
)? Sim

Exemplo
Seja f(n) = 3n3 + 2n2 + n
Pergunta-se:
f(n) é O(n2
)?
f(n) é O(n3
)?
f(n) é O(n4
)?

Exemplo
Seja f(n) = 3n3 + 2n2 + n
Pergunta-se:
f(n) é O(n2
)? Não
f(n) é O(n3
)?
f(n) é O(n4
)?

Exemplo
Seja f(n) = 3n3 + 2n2 + n
Pergunta-se:
f(n) é O(n2
)? Não
f(n) é O(n3
f(n) é O(n4
)?

Exemplo
Seja f(n) = 3n3 + 2n2 + n
Pergunta-se:
f(n) é O(n2
)? Não
f(n) é O(n3
f(n) é O(n4
)? Sim

Deﬁniçã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

Exemplo
Seja f(n) = 3n3 + 2n2
Pergunta-se:
f(n) é Ω(n3
)?
f(n) é Ω(n2
)?

Exemplo
Seja f(n) = 3n3 + 2n2
Pergunta-se:
f(n) é Ω(n3
f(n) é Ω(n2
)?

Exemplo
Seja f(n) = 3n3 + 2n2
Pergunta-se:
f(n) é Ω(n3
f(n) é Ω(n2
)? Sim

Deﬁniçã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

Exemplo
Seja f(n) = n2
3 − 2n
Pergunta-se:
f(n) é Θ(n2
)?

Exemplo
Seja f(n) = n2
3 − 2n
Pergunta-se:
f(n) é Θ(n2
)? Sim, assumindo c1 = 1
21 , c2 = 1
3 e m = 7

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 deﬁnido
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

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!

Complexidade constante f(n) = O(1)
Independe do tamanho de n
Instruções são executadas um número ﬁxo de vezes
Exemplo: algoritmo de inserção de um aluno

Complexidade logarítmica f(n) = O(lg n)
Ocorre normalmente em problemas que dividem o
problema em problemas menores
Exemplo: busca binária

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

Complexidade sem nome deﬁnido 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...

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...

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...

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 ﬁca elevado
ao quadrado
Exemplo: Problema do Caixeiro Viajante usando
programação dinâmica

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 ﬁca muito
mais do que elevado ao quadrado
Exemplo: Problema do Caixeiro Viajante

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?

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

4. Métodos de Ordenação – Conteúdo
1 Introdução 3
Conceitualização 72
SelectionSort (Seleção) 77
BubbleSort (Bolha) 83
InsertionSort (Inserção) 87
ShellSort 94
QuickSort 99

Métodos de Ordenação
Conceitualização

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.)

Classiﬁcaçã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

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)

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 Eﬁcientes:
ShellSort, QuickSort
internos
O(n lg(n))
grandes arquivos
Análise C(n)

SelectionSort (Seleção)

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 }

Análise por número de comparações – C(n)
C(n) =
n−1
i=1
n
j=i+1
1
...
C(n) =

C(n) =
n−1
i=1
n
j=i+1
1
...
C(n) =
n2
2
−
n
2
= O( )

C(n) =
n−1
i=1
n
j=i+1
1
...
C(n) =
n2
2
−
n
2
= O(n2
)

Análise por número de movimentações – M(n)
M(n) =
n−1
i=1
3
...
M(n) =

M(n) =
n−1
i=1
3
...
M(n) = 3(n − 1) = O( )

M(n) =
n−1
i=1
3
...
M(n) = 3(n − 1) = O(n)

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

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
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 }

BubbleSort (Bolha)

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 }

BubbleSort — Resumo
Ordenação interna
C(n) = O(n2)
M(n) = O(n2)
não é estável
sensível à entrada (mas por quê?)

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
15 int v[] = {5,2,4,6,1,3};
16 int i;
18 bubbleSort(v, tam);
19
20 for (i=0; i<tam; i++){
22 }
23 printf("n");
24 return 0;
25 }

InsertionSort (Inserção)

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 }

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
)

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
)

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
)

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
)

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

InsertionSort — Resumo
Ordenação interna
C(n) = O(n2), mas C(n) = Ω(n)
M(n) = O(n2), mas M(n) = Ω(n)
estável
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

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
17 int v[] = {5,2,4,6,1,3};
18 int i;
20 insertionSort(v, tam);
21
22 for (i=0; i<tam; i++){
24 }
25 printf("n");
26 return 0;
27 }

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?

ShellSort

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 }

Ainda não se sabe o razão pelo qual esse método é
eﬁciente
Análise complexa
principalmente sequência de incrementos
C1(n) = O(n1.25
)
C2(n) = O(n lg(n))

ShellSort — Resumo
Ordenação interna
C1(n) = O(n1.25)
C2(n) = O(n lg(n))
não é estável
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

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
22 int v[] = {5,2,4,6,1,3};
23 int i;
25 shellSort(v, tam);
26 /* um for que imprime o arranjo ordenado */
27 return 0;
28 }

QuickSort

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”

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 ﬁnal, 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

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 }

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 }

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))

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

QuickSort — Resumo
Ordenação interna
C(n) = O(n lg(n))
não é estável
QuickSort — Uso na prática
Algoritmo mais eﬁciente
Algoritmo mais usado

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 }
2 int v[] = {5,2,4,6,1,3};
3 int i;
5 quickSort(v, tam);
6
7 for (i=0; i<tam; i++){
9 }
10 printf("n");
11 return 0;
12 }

5. Pesquisa em Memória Primária – Conteúdo
1 Introdução 3
Pesquisa Sequencial 109
Pesquisa Binária 112
Árvores de Pesquisa 115
Árvores Binárias sem Balanceamento 117
Árvores Binárias com Balanceamento 134

Pesquisa em Memória Primária
Pesquisa Sequencial

Pesquisa em Memória Primária – Pesquisa Sequencial
Pesquisa Sequencial, algum problema?
2 int i;
3 for (i=0; i<tam; i++){
4 if ( v[i] == x ){
5 return i;
6 }
7 }
8 return -1;
9 }
Pior caso: f(n) = n
n + 1
2

Pesquisa em Memória Primária – Pesquisa Sequencial
Sim!
Um algoritmo de pesquisa O(n) pode não ser suﬁciente
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

Pesquisa Binária

Pesquisa em Memória Primária – Pesquisa Binária
Pesquisa Binária
Uma pesquisa em um arranjo ordenado pode ser muito
mais eﬁciente
Pense bem Tec-Toy
Exemplo (procurando 9):
1 1 2 3 4 5 6 7 8 9 10 11 12 13

Pesquisa Binária
mais eﬁciente
Pense bem Tec-Toy
1 1 2 3 4 5 6 7 8 9 10 11 12 13
2 8 9 10 11 12 13

Pesquisa Binária
mais eﬁciente
Pense bem Tec-Toy
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

Pesquisa Binária
mais eﬁciente
Pense bem Tec-Toy
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?

Análise
A cada interação divide-se o arranjo ao meio
Logo, O(lg(n))
No entanto:
1
Tipo Abstrato de Dados

Análise
Logo, O(lg(n))
No entanto:
E o custo para manter ordenado?
1

Análise
Logo, O(lg(n))
No entanto:
Algum outro TAD1
resolve? (e.g., lista, ﬁla, pilha, etc.)
1

Análise
Logo, O(lg(n))
No entanto:
Algum outro TAD1
resolve? (e.g., lista, ﬁla, pilha, etc.)
Problema se resolverá?
Árvore Binária?
1

Árvores de Pesquisa

Pesquisa em Memória Primária – Árvores de Pesquisa
Árvores de Pesquisa
Estrutura de dados muito eﬁciente
Usada quando necessita-se (em totalidade ou parcialmente)
acessos direto e sequencial eﬁcientes
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
...

Árvores Binárias sem Balanceamento

Á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 ﬁlhos
(i.e., esq = dir = NULL)
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”
Nível 0
Nível 1
.
.
.

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 }

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 }

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 }

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 }

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

Função preOrdem
1 void preOrdem (TNo *no){
2 if (no != NULL){
4 preOrdem(no->esq);
5 preOrdem(no->dir);
6 }
7 }
Resultado
G B A E C D F H I J

Função posOrdem
1 void posOrdem (TNo *no){
2 if (no != NULL){
3 posOrdem(no->esq);
4 posOrdem(no->dir);
6 }
7 }
Resultado
A D C F E B J I H G

Remoção – Forma 1
Retirada de um nodo folha (J)
Simples!

Retirada de um nodo com um ﬁlho (H)
Meramente simples!

Retirada de um nodo com dois ﬁlhos (B)
Não tão simples!

Após as remoções...

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 }

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 }

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

Árvores Binárias com Balanceamento

Árvores de Pesquisa – Árvores Binárias com Balanceamento
Árvore Balanceada
Árvore não Balanceada
Deﬁniçã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

Referências
Thomas Cormen.
Introduction to algorithms.
MIT Press, 3 edition, 2009.
Paulo Feoﬁloff.
Algoritmos em Linguagem C.
Elsevier, 2009.
Nivio Ziviani.
Projeto de algoritmos com implementações em Pascal e C.
Cengage Learning, 3 edition, 2010.

Apostila Algoritmos e Estrutura de Dados (AEDS)

Mais conteúdo relacionado

Mais procurados (20)

Destaque (20)

Semelhante a Apostila Algoritmos e Estrutura de Dados (AEDS) (20)

Mais de Ricardo Terra (20)

Último (20)

Apostila Algoritmos e Estrutura de Dados (AEDS)