Objetivo e Ementa

Objetivo
Introdução a algoritmos e estruturas de dados.

Estruturas de Dados I
Ementa
Complexidade de algoritmos e notação assintótica, Listas
lineares, simplesmente encadeadas, duplamente
Instituto Multidisciplinar encadeadas e circulares, Árvores binárias, árvores binárias
Universidade Federal Rural do Rio de Janeiro de busca, balanceadas, AVL, rubro-negras, árvores B, e
Listas de prioridades.

Conteúdo Programático Conteúdo Programático

Conteúdo Programático Listas

Introdução 1. Listas Lineares, Busca Linear

2. Busca Binária
1. Introdução
3. Algoritmos de Ordenação
2. Complexidade de Algoritmos
4. Pilhas e Filas
3. Pior Caso, Caso Médio e Melhor Caso
5. Alocação Encadeada
4. Notações Assintóticas
6. Listas Simplesmente Encadeadas
5. Recursividade
7. Listas Duplamente Encadeadas
8. Listas Circulares

Conteúdo Programático Avaliação

Árvores Notas
1. Árvores, Árvores Binárias, Algoritmos de Busca MP= P1 + P2 ( +T ) MF= OP + M2
2. Árvores Binárias de Busca 2 2
3. Árvores Balanceadas, Árvores AVL e Algoritmos
P1 = Prova 1
4. Árvores Graduadas, Árvores Rubro-Negras P2 = Prova 2
5. Árvores B e Algoritmos T = Trabalhos (Listas de Exercícios e Implementações)
MP = Média Parcial
6. Listas de Prioridades e Algoritmos
M1 = Menor Nota dentre P1 e P2
7. Heapsort M2 = Maior Nota dentre P1 e P2
OP = Prova Optativa (considerada apenas se a nota obtida for maior do que a
menor nota dentre P1 e P2)
MF = Média Final

1
Introdução Introdução

Algoritmos - Definição A seqüência de entrada a1 , a2 ,L , an do problema de

ordenação é denominada Instância.
Procedimento computacional que toma algum valor, ou
conjunto de valores, como entrada e produz um valor, ou
conjunto de valores, como saída. Um algoritmo é Correto se termina com uma resposta correta
Ferramenta para resolvermos um problema computacional para toda instância de entrada.
bem definido.

Ex.:
Problema de Ordenação
Entrada : a1 , a2 , L , an
Saída : a1′ , a2′ ,L , an′
Algoritmo de Ordenação - Método da Inserção
Entrada : a1 , a2 ,L , an
(seqüência de n números) Saída : a1′ , a2′ ,L , an′
(reordenação tq a1′ ≤ a′2 ≤ L ≤ a′n )

Introdução Introdução

Método da Inserção Execução: 7

1. Para j = 2 até n faça
2. aux = Vetor[ j ];
3. i = j - 1;
4. Enquanto i > 0 e Vetor[ i ] > aux faça
5. Vetor[ i + 1] = Vetor[ i ];
6. i = i - 1;
7. Vetor[ i + 1] = aux;

Instância:
7 3 4 9 2 11

Introdução Introdução
Execução: 7 3 Execução: 7 3

2
Introdução Introdução
Execução: 7 3 Execução: 7 3

3 7 3 7 4

Introdução Introdução
Execução: 7 3 Execução: 7 3

3 7 4 3 7 4

3 4 7

Introdução Introdução
Execução: 7 3 Execução: 7 3

3 7 4 3 7 4

3 4 7 9 3 4 7 9

3
Introdução Introdução
Execução: 7 3 Execução: 7 3

3 7 4 3 7 4

3 4 7 9 3 4 7 9

3 4 7 9 3 4 7 9 2

Introdução Introdução
Execução: 7 3 Execução: 7 3

3 7 4 3 7 4

3 4 7 9 3 4 7 9

3 4 7 9 2 3 4 7 9 2

2 3 4 7 9

Introdução Introdução
Execução: 7 3 Execução: 7 3

3 7 4 3 7 4

3 4 7 9 3 4 7 9

3 4 7 9 2 3 4 7 9 2

2 3 4 7 9 11 2 3 4 7 9 11

4
Introdução Complexidade de Algoritmos
Execução: 7 3 Complexidade de Tempo

3 7 4 Descrita como uma função no tamanho da entrada.

Considerando uma seqüência com n elementos, qual o
3 4 7 9 tempo de execução do Método da Inserção ?

Tempo: custo vezes

3 4 7 9 2
1. Para j = 2 até n faça c1 n
2. aux = Vetor[ j ]; c2 n-1
2 3 4 7 9 11 3. i = j - 1; c3 n-1
∑
n
4. Enquanto i > 0 e Vetor[ i ] > aux faça c4 j =2 j
t
∑
n
Saída: 5. Vetor[ i + 1] = Vetor[ i ]; c5 j =2
(t j − 1)
2 3 4 7 9 11
∑
n
6. i = i - 1; c6 j =2
(t j − 1)
7. Vetor[ i + 1] = aux; c7 n-1

Complexidade de Algoritmos Complexidade de Algoritmos

Seja tj o número de vezes em que o laço Enquanto é testado. Pior Caso

Então: Instância:
11 9 7 4 3 2
T ( n ) = c1n + c 2 ( n − 1) + c3 ( n − 1) +

+ c 4 ∑ j = 2 t j + c5 ∑ j = 2 (t j − 1) + c6 ∑ j = 2 (t j − 1) +
n n n
Neste caso, para cada j teremos que percorrer todo o array.

+ c 7 ( n − 1) T ( n) = an 2 + bn + c ( função quadrática )

Caso Médio
Análises
Frequentemente da mesma ordem do pior caso. Suponha que
Pior Caso escolhemos randomicamente n números e aplicamos o Método da
Caso Médio Inserção. Em média, tj = j / 2.

Melhor Caso T (n) = an 2 + bn + c ( função quadrática )

Complexidade de Algoritmos Notações Assintóticas

Melhor Caso Notação Θ

Instância:
2 3 4 7 9 11
Tempo de execução assintótico: descrito por uma função cujo
Neste caso, para cada j temos tj = 1. domínio é IN. (Consideraremos o domínio IR.)

T ( n) = an + b ( função linear )
Definição
Complexidade de Espaço Uma função f (n) pertence ao conjunto Θ(g(n)) se existem
Montante de memória ou armazenamento computacional constantes positivas c1 e c2 tais que f (n) pode ser limitada
requerido por um algoritmo. inferiormente por c1 g(n) e superiormente por c2 g(n), para n
suficientemente grande.
Obs.: O armazenamento requerido para a entrada ou para a saida, em alguns casos,
não é considerado como parte da complexidade de espaço.

5
Notações Assintóticas Notações Assintóticas

Notação Θ Notação O

Definição
Θ( g ( n)) = { f ( n) : existem constantes positivas c1 , c2 , e n0 Uma função f (n) pertence ao conjunto O(g(n)) se existe uma
t ais que 0 ≤ c1 g (n) ≤ f (n) ≤ c2 g ( n) constante positiva c tal que f (n) pode ser limitada
superiormente por cg(n), para n suficientemente grande.
para todo n ≥ n0 }
O( g ( n)) = { f ( n) : existem constantes positivas c e n0
tais que 0 ≤ f (n) ≤ cg ( n) para todo n ≥ n0 }
f (n) = Θ(g(n)) ⇔ f (n) ∈ Θ(g(n))

f (n) = O(g(n)) ⇔ f (n) ∈ O(g(n))

Notações Assintóticas Notações Assintóticas

Notação Ω Gráficos

Definição
c2 g ( n) f (n)
Uma função f (n) pertence ao conjunto Ω (g(n)) se existe uma f (n)
c g (n)

constante positiva c tal que f (n) pode ser limitada inferiormente

por cg(n), para n suficientemente grande. f (n)
c1 g ( n) c g (n)

Ω( g ( n)) = { f ( n) : existem constantes positivas c e n0 n n n

tais que 0 ≤ cg (n) ≤ f ( n) para todo n ≥ n0 } n0 n0 n0

f ( n) = Θ( g ( n)) f ( n) = O ( g (n)) f (n) = Ω( g ( n))

f (n) = Ω(g(n)) ⇔ f (n) ∈ Ω(g(n))

Notações Assintóticas Notações Assintóticas

Exemplos: Limites

5n2 + 15 = O (n2), visto que 5n2 + 15 ≤ 6n2, ∀ n ≥ 4.

f ( n)
5n2 + 15 = O (n3), visto que 5n2 + 15 ≤ n3, ∀ n ≥ 6. Se temos 0 < lim < ∞,
n →∞ g ( n)
então f (n) ∈ Θ( g (n)).
Escrevemos O(n), ao invés de O (5n + 5).
Da mesma forma, escrevemos O (log n).

Temos n2 + 100 = Ω (n2) ou n2 = Ω (n2 - 100). E n2 = Ω (n0.9). f ( n)

Se temos 0 ≤ lim <∞
,
5n log2 n - 10 = θ (n log n). n →∞ g ( n)
f (n) = O (g(n)) e f (n) = Ω(g(n)) sse f (n) = θ(g(n)). então f (n) ∈ O ( g (n)).

6
Notações Assintóticas Notações Assintóticas

Limites Tempos de Execução Assintóticos

Θ(1): Impossível fazer melhor.

f ( n)
Se temos 0 < lim , Θ(log n): Tempo de operação de único acesso em muitas
n →∞ g ( n )
estruturas de dados eficientes (e.g. árvores binárias
então f ( n) ∈ Ω( g ( n)). balanceadas). Tempo de execução da Busca Binária.
Θ(n): Tempo de execução do algoritmo mais rápido para um
problema, dado que é necessário tempo Θ(n)
apenas para a leitura da entrada.
Θ(n log n): Tempo de execução dos melhores algoritmos de
ordenação.

(D. Mount)

Notações Assintóticas Notações Assintóticas

Tempos de Execução Assintóticos Tempos de Execução Assintóticos

Θ(n2), Θ(n3): Tempo polinomial. Tempo de execução

aceitável ou quando o expoente é pequeno ou quando o n 3 n 2 n lg n
20
tamanho de dados não é muito grande (e.g. n ≤ 1000).
n
Θ(2n), Θ(3n): Tempo exponencial. Somente aceitável
quando (1) entrada n ≤ 50 (2) este é um tempo de
execução de pior caso que raramente irá ocorrer em 10
instâncias práticas. lg n
Θ(n!), Θ(nn): Aceitável somente para entradas realmente 1
pequenas (e.g. n ≤ 20).
10 20
(D. Mount)

Recursividade Recursividade

Algoritmo Recursivo Fatorial

Definição
Algoritmo definido em termos de si próprio, possuindo: Fatorial(int n) {
if(n > 0) return n*Fatorial(n-1);
Um passo trivialmente resolvido, ou critério de parada. return 1;
Passo recursivo no qual resolvemos um subproblema do problema }
inicial.

Exs.: Fatorial
Fibonacci
Torres de Hanoi
Algoritmos de Ordenação - MergeSort e QuickSort

7
Recursividade Recursividade

Fibonacci Problema das Torres de Hanói

n discos
int F(int n){
if((n==0)||(n==1)) return n; A B C
else return F(n-1)+F(n-2); n -1 discos n -1 discos n -1 discos

}
A B C A B C A B C

(Obs.: Nº chamadas cresce de forma proibitiva.) Hanoi(int n,int A,int B,int C) {

if(n==1) Move(A,B); // Imprimir
5 else {
Hanoi(n-1, A, C, B);
4 3
Move(A,B);
3 2 2 1
Hanoi(n-1, C, B, A);
2 1 1 0 1 0
}
1 0
}

Recursividade Recursividade
MergeSort MergeSort - Análise
MergeSort(Array A, int p , int r) { Teorema 1 (Master Theorem): Sejam a ≥ 1 e b > 1 constantes,
if(p < r){ seja f (n) uma função, e seja T (n) definida sobre os inteiros não
q = (p + r)/2;
negativos pela recorrência
MergeSort(A, p, q);
MergeSort(A, q+1, r); T (n) = aT (n / b) + f (n)
Merge(A, p, q, r); onde interpretamos n / b como ou n / b  ou n / b . Então T (n) pode ser
} limitada assintoticamente como segue.
}
Entrada: 1. Se f ( n) = O( n log a −ε ) para alguma constante ε > 0 , então
b

3 5 6 7 8 9 10 16
[ 16, 9, 7, 5, 10, 8, 3, 6 ] T (n) = Θ(n log a ).b

Saída: 5 7 9 16 3 6 8 10 2. Se f ( n) = Θ( n log a ), então T (n) = Θ(n log a log

b
. n) b

[ 3, 5, 6, 7, 8, 9, 10, 16 ] 3. Se f ( n) = Ω( n log a +ε ) para alguma constante ε > 0 , e se

b

9 16 5 7 8 10 3 6
af ( n / b) ≤ cf ( n ) para alguma constante c < 1 e todo n
16 9 7 5 10 8 3 6 suficientemente grande, então T (n) = Θ( f ( n)). (Cormen et al.)

Recursividade Observações

Considerando Tempos de Execução Assintóticos

T (n ) = 2T (n / 2) + Θ( n),
Alguns dos algoritmos estudados possuem complexidade de
temos a = 2,
tempo O(nk) no pior caso (algoritmos de tempo polinomial).
b = 2, e
f (n) = Θ(n). Uma questão que surge é se podemos resolver todos os
problemas em tempo polinomial. E a resposta é não.
Assim, com a aplicação do Teorema 1, temos
T (n ) = Θ ( n log n) Existem também problemas que não podem ser resolvidos em
tempo O(nk), para qualquer constante k.
Existem problemas que não podem ser resolvidos por qualquer
computador, independentemente do tempo disponível.
Merge Sort