Pa2e Cap1

Algoritmos e
Estruturas de Dados II
Introduo
Antonio Alfredo Ferreira Loureiro
loureiro@dcc.ufmg.br
http://www.dcc.ufmg.br/~loureiro
UFMG/ICEx/DCC Algoritmos e Estruturas de Dados II 1
Algoritmos, estruturas de dados e programas
Os algoritmos fazem parte do dia-a-dia das pessoas. Exemplos de algorit-
mos:
instrues para o uso de medicamentos;
indicaes de como montar um aparelho;
uma receita de culinria.
Seqncia de aes executveis para a obteno de uma soluo para um
determinado tipo de problema.
Segundo Dijkstra, um algoritmo corresponde a uma descrio de um padro
de comportamento, expresso em termos de um conjunto nito de aes.
Executando a operao a +b percebemos um padro de comportamento,
mesmo que a operao seja realizada para valores diferentes de a e b.
Estruturas de dados
Estruturas de dados e algoritmos esto intimamente ligados:
No se pode estudar estruturas de dados sem considerar os algoritmos
associados a elas;
Assim como a escolha dos algoritmos em geral depende da representao
e da estrutura dos dados.
Para resolver um problema necessrio escolher uma abstrao da reali-
dade, em geral mediante a denio de um conjunto de dados que representa
a situao real.
A seguir, deve ser escolhida a forma de representar esses dados.
Escolha da representao dos dados
A escolha da representao dos dados determinada, entre outras, pelas
operaes a serem realizadas sobre os dados.
Considere a operao de adio:
Para pequenos nmeros, uma boa representao por meio de barras
verticais (caso em que a operao de adio bastante simples).
J a representao por dgitos decimais requer regras relativamente com-
plicadas, as quais devem ser memorizadas.
Quando consideramos a adio de grandes nmeros mais fcil a repre-
sentao por dgitos decimais (devido ao princpio baseado no peso relativo
a posio de cada dgito).
Programas
Programar basicamente estruturar dados e construir algoritmos.
Programas so formulaes concretas de algoritmos abstratos, baseados em
representaes e estruturas especcas de dados.
Programas representam uma classe especial de algoritmos capazes de
serem seguidos por computadores.
Um computador s capaz de seguir programas em linguagem de mquina
(seqncia de instrues obscuras e desconfortveis).
necessrio construir linguagens mais adequadas, que facilitem a tarefa de
programar um computador.
Uma linguagem de programao uma tcnica de notao para programar,
com a inteno de servir de veculo tanto para a expresso do raciocnio
algortmico quanto para a execuo automtica de um algoritmo por um com-
putador.
Tipos de dados
Caracteriza o conjunto de valores a que uma constante pertence, ou que
podem ser assumidos por uma varivel ou expresso, ou que podem ser ge-
rados por uma funo.
Tipos simples de dados so grupos de valores indivisveis (como os tipos
bsicos integer, boolean, char e real do Pascal).
Exemplo: uma varivel do tipo boolean pode assumir o valor verdadeiro
ou o valor falso, e nenhum outro valor.
Os tipos estruturados em geral denem uma coleo de valores simples, ou
um agregado de valores de tipos diferentes.
Tipos abstratos de dados (TADs)
Modelo matemtico, acompanhado das operaes denidas sobre o mode-
lo.
Exemplo: o conjunto dos inteiros acompanhado das operaes de adio,
subtrao e multiplicao.
TADs so utilizados extensivamente como base para o projeto de algoritmos.
A implementao do algoritmo em uma linguagem de programao especca
exige a representao do TAD em termos dos tipos de dados e dos operado-
res suportados.
A representao do modelo matemtico por trs do tipo abstrato de dados
realizada mediante uma estrutura de dados.
Podemos considerar TADs como generalizaes de tipos primitivos e proce-
dimentos como generalizaes de operaes primitivas.
O TAD encapsula tipos de dados:
A denio do tipo e todas as operaes cam localizadas numa seo do
programa.
Implementao de TADs
Considere uma aplicao que utilize uma lista de inteiros. Poderamos denir
o TAD Lista, com as seguintes operaes:
1. Faa a lista vazia;
2. Obtenha o primeiro elemento da lista; se a lista estiver vazia, ento retorne
nulo;
3. Insira um elemento na lista.
H vrias opes de estruturas de dados que permitem uma implementao
eciente para listas (por exemplo, o tipo estruturado arranjo).
Implementao de TADs
Cada operao do tipo abstrato de dados implementada como um procedi-
mento na linguagem de programao escolhida.
Qualquer alterao na implementao do TAD ca restrita parte encapsu-
lada, sem causar impactos em outras partes do cdigo.
Cada conjunto diferente de operaes dene umTADdiferente, mesmo atuem
sob um mesmo modelo matemtico.
A escolha adequada de uma implementao depende fortemente das oper-
aes a serem realizadas sobre o modelo.
Medida do tempo de execuo de um programa
O projeto de algoritmos fortemente inuenciado pelo estudo de seus com-
portamentos.
Depois que um problema analisado e decises de projeto so nalizadas,
necessrio estudar as vrias opes de algoritmos a serem utilizados, con-
siderando os aspectos de tempo de execuo e espao ocupado.
Algoritmos so encontrados em todas as reas de Cincia da Computao.
Tipos de problemas na anlise de algoritmos
Anlise de um algoritmo particular
Qual o custo de usar um dado algoritmo para resolver um problema espec-
co?
Caractersticas que devem ser investigadas:
anlise do nmero de vezes que cada parte do algoritmo deve ser execu-
tada,
estudo da quantidade de memria necessria.
Tipos de problemas na anlise de algoritmos
Anlise de uma classe de algoritmos
Qual o algoritmo de menor custo possvel para resolver um problema par-
ticular?
Toda uma famlia de algoritmos investigada.
Procura-se identicar um que seja o melhor possvel.
Colocam-se limites para a complexidade computacional dos algoritmos per-
tencentes classe.
Custo de um algoritmo
Determinando o menor custo possvel para resolver problemas de uma dada
classe, temos a medida da diculdade inerente para resolver o problema.
Quando o custo de um algoritmo igual ao menor custo possvel, o algoritmo
timo para a medida de custo considerada.
Podem existir vrios algoritmos para resolver o mesmo problema.
Se a mesma medida de custo aplicada a diferentes algoritmos, ento
possvel compar-los e escolher o mais adequado.
Medida do custo pela execuo do programa em
uma plataforma real
Tais medidas so bastante inadequadas e os resultados jamais devem ser
generalizados:
os resultados so dependentes do compilador que pode favorecer algumas
construes em detrimento de outras;
os resultados dependem do hardware;
quando grandes quantidades de memria so utilizadas, as medidas de
tempo podem depender deste aspecto.
Apesar disso, h argumentos a favor de se obterem medidas reais de
tempo.
Por exemplo, quando h vrios algoritmos distintos para resolver um
mesmo tipo de problema, todos com um custo de execuo dentro de uma
mesma ordem de grandeza.
Assim, so considerados tanto os custos reais das operaes como os
custos no aparentes, tais como alocao de memria, indexao, carga,
dentre outros.
Medida do custo por meio de um modelo
matemtico
Usa um modelo matemtico baseado em um computador idealizado.
Deve ser especicado o conjunto de operaes e seus custos de execues.
mais usual ignorar o custo de algumas das operaes e considerar apenas
as operaes mais signicativas.
Por exemplo, algoritmos de ordenao:
consideramos o nmero de comparaes entre os elementos do conjunto
a ser ordenado e ignoramos as operaes aritmticas, de atribuio e ma-
nipulaes de ndices, caso existam.
Funo de complexidade
Para medir o custo de execuo de um algoritmo comum denir uma funo
de custo ou funo de complexidade f.
f(n) a medida do tempo necessrio para executar um algoritmo para um
problema de tamanho n.
Funo de complexidade de tempo: f(n) mede o tempo necessrio para
executar um algoritmo para um problema de tamanho n.
Funo de complexidade de espao: f(n) mede a memria necessria
para executar um algoritmo para um problema de tamanho n.
Utilizaremos f para denotar uma funo de complexidade de tempo daqui
para a frente.
Na realidade, a complexidade de tempo no representa tempo diretamente,
mas o nmero de vezes que determinada operao considerada relevante
executada.
Exemplo: Maior elemento
Considere o algoritmo para encontrar o maior elemento de um vetor de in-
teiros A[1..n], n 1.
function Max (var A: Vetor): integer;
var i, Temp: integer;
begin
Temp := A[1];
for i:=2 to n do if Temp < A[i] then Temp := A[i];
Max := Temp;
end;
Seja f uma funo de complexidade tal que f(n) o nmero de compara-
es entre os elementos de A, se A contiver n elementos.
Logo f(n) = n 1, para n 1.
Vamos provar que o algoritmo apresentado no programa acima timo.
Exemplo: Maior elemento
Teorema: Qualquer algoritmo para encontrar o maior elemento de um conjunto
com n elementos, n 1, faz pelo menos n 1 comparaes.
Prova: Cada um dos n 1 elementos tem de ser mostrado, por meio de com-
paraes, que menor do que algum outro elemento.
Logo n 1 comparaes so necessrias. 2
O teorema acima nos diz que, se o nmero de comparaes for utilizado
como medida de custo, ento a funo Max do programa anterior tima.
Tamanho da entrada de dados
A medida do custo de execuo de um algoritmo depende principalmente do
tamanho da entrada dos dados.
comum considerar o tempo de execuo de um programa como uma funo
do tamanho da entrada.
Para alguns algoritmos, o custo de execuo uma funo da entrada parti-
cular dos dados, no apenas do tamanho da entrada.
No caso da funo Max do programa do exemplo, o custo uniforme sobre
todos os problemas de tamanho n.
J para um algoritmo de ordenao isso no ocorre: se os dados de en-
trada j estiverem quase ordenados, ento o algoritmo pode ter que trabalhar
menos.
Melhor caso, pior caso e caso mdio
Melhor caso:
Menor tempo de execuo sobre todas as entradas de tamanho n.
Pior caso:
Maior tempo de execuo sobre todas as entradas de tamanho n.
Se f uma funo de complexidade baseada na anlise de pior caso, o
custo de aplicar o algoritmo nunca maior do que f(n).
Caso mdio (ou caso esperado):
Mdia dos tempos de execuo de todas as entradas de tamanho n.
Melhor caso, pior caso e caso mdio
Na anlise do caso esperado, supe-se uma distribuio de probabilidades
sobre o conjunto de entradas de tamanho n e o custo mdio obtido com
base nessa distribuio.
A anlise do caso mdio geralmente muito mais difcil de obter do que as
anlises do melhor e do pior caso.
comum supor uma distribuio de probabilidades em que todas as entradas
possveis so igualmente provveis.
Na prtica isso nem sempre verdade.
Exemplo: Registros de um arquivo
Considere o problema de acessar os registros de um arquivo.
Cada registro contm uma chave nica que utilizada para recuperar reg-
istros do arquivo.
O problema: dada uma chave qualquer, localize o registro que contenha esta
chave.
O algoritmo de pesquisa mais simples o que faz a pesquisa seqencial.
Seja f uma funo de complexidade tal que f(n) o nmero de registros
consultados no arquivo (nmero de vezes que a chave de consulta com-
parada com a chave de cada registro).
Melhor caso: f(n) = 1 (registro procurado o primeiro consultado);
Pior caso: f(n) = n (registro procurado o ltimo consultado ou
no est presente no arquivo);
Caso mdio: f(n) =
n+1
2
.
Exemplo: Registros de um arquivo
No estudo do caso mdio, vamos considerar que toda pesquisa recupera um
registro.
Se p
i
for a probabilidade de que o i-simo registro seja procurado, e con-
siderando que para recuperar o i-simo registro so necessrias i compara-
es, ento
f(n) = 1 p
1
+2 p
2
+3 p
3
+ +n p
n
.
Para calcular f(n) basta conhecer a distribuio de probabilidades p
i
.
Se cada registro tiver a mesma probabilidade de ser acessado que todos os
outros, ento p
i
= 1/n, 1 i n.
Neste caso f(n) =
1
n
(1 +2 +3 + +n) =
1
n
_
n(n+1)
2
_
=
n+1
2

A anlise do caso esperado revela que uma pesquisa com sucesso examina
aproximadamente metade dos registros.
Exemplo: Maior e menor elementos (1)
Considere o problema de encontrar o maior e o menor elemento de um vetor
de inteiros A[1..n], n 1.
Um algoritmo simples pode ser derivado do algoritmo apresentado no pro-
grama para achar o maior elemento.
procedure MaxMin1 (var A: Vetor; var Max, Min: integer);
var i: integer;
begin
Max := A[1]; Min := A[1];
for i := 2 to n do
begin
if A[i] > Max then Max := A[i]; {Testa se A[i] contm o maior elemento}
if A[i] < Min then Min := A[i]; {Testa se A[i] contm o menor elemento}
end;
end;
Seja f(n) o nmero de comparaes entre os elementos de A, se A tiver n
elementos.
Logo f(n) = 2(n 1), para n > 0, para o melhor caso, pior caso e caso
mdio.
MaxMin1 pode ser facilmente melhorado:
a comparao A[i] < Min s necessria quando o resultado da compara-
o A[i] > Max for falso.
procedure MaxMin2 (var A: Vetor; var Max, Min: integer);
var i: integer;
begin
Max := A[1]; Min := A[1];
for i := 2 to n do
if A[i] > Max
then Max := A[i]
else if A[i] < Min then Min := A[i];
end;
Para a nova implementao temos:
Melhor caso: f(n) = n 1 (quando os elementos esto em ordem
crescente);
Pior caso: f(n) = 2(n 1) (quando os elementos esto em ordem
decrescente);
Caso mdio: f(n) =
3n
2

3
2
.
Caso mdio:
A[i] maior do que Max a metade das vezes.
Logo, f(n) = n 1 +
n1
2
=
3n
2

3
2
, para n > 0.
Considerando o nmero de comparaes realizadas, existe a possibilidade
de obter um algoritmo mais eciente:
1. Compare os elementos de A aos pares, separando-os em dois subcon-
juntos (maiores em um e menores em outro), a um custo de n/2| com-
paraes.
2. O mximo obtido do subconjunto que contm os maiores elementos, a
um custo de n/2| 1 comparaes.
3. O mnimo obtido do subconjunto que contm os menores elementos, a
um custo de n/2| 1 comparaes.
Contm o mnimo
...
...
Contm o mximo
procedure MaxMin3(var A: Vetor;
var Max, Min: integer);
var i,
FimDoAnel: integer;
begin
{Garante uma qte par de elementos no vetor para evitar caso de exceo}
if (n mod 2) > 0
then begin
A[n+1] := A[n];
FimDoAnel := n;
end
else FimDoAnel := n-1;
{Determina maior e menor elementos iniciais}
if A[1] > A[2]
then begin
Max := A[1]; Min := A[2];
end
else begin
Max := A[2]; Min := A[1];
end;
i:= 3;
while i <= FimDoAnel do
begin
{Compara os elementos aos pares}
if A[i] > A[i+1]
then begin
if A[i] > Max then Max := A[i];
if A[i+1] < Min then Min := A[i+1];
end
else begin
if A[i] < Min then Min := A[i];
if A[i+1] > Max then Max := A[i+1];
end;
i:= i + 2;
end;
end;
Os elementos de A so comparados dois a dois e os elementos maiores so
comparados com Max e os elementos menores so comparados com Min.
Quando n mpar, o elemento que est na posio A[n] duplicado na
posio A[n +1] para evitar um tratamento de exceo.
Para esta implementao, f(n) =
n
2
+
n2
2
+
n2
2
=
3n
2
2, para n > 0,
para o melhor caso, pior caso e caso mdio.
Comparao entre os algoritmos
MaxMin1, MaxMin2 e MaxMin3
A tabela abaixo apresenta uma comparao entre os algoritmos dos progra-
mas MaxMin1, MaxMin2 e MaxMin3, considerando o nmero de compara-
es como medida de complexidade.
Os algoritmos MaxMin2 e MaxMin3 so superiores ao algoritmo MaxMin1 de
forma geral.
O algoritmo MaxMin3 superior ao algoritmo MaxMin2 com relao ao pior
caso e bastante prximo quanto ao caso mdio.
Os trs f(n)
algoritmos Melhor caso Pior caso Caso mdio
MaxMin1 2(n 1) 2(n 1) 2(n 1)
MaxMin2 n 1 2(n 1) 3n/2 3/2
MaxMin3 3n/2 2 3n/2 2 3n/2 2
Limite inferior: Uso de um orculo
possvel obter um algoritmo MaxMin mais eciente?
Para responder temos de conhecer o limite inferior para essa classe de al-
goritmos.
Tcnica muito utilizada:
Uso de um orculo.
Dado um modelo de computao que expresse o comportamento do algo-
ritmo, o orculo informa o resultado de cada passo possvel (no caso, o resul-
tado de cada comparao).
Para derivar o limite inferior, o orculo procura sempre fazer com que o algo-
ritmo trabalhe o mximo, escolhendo como resultado da prxima comparao
aquele que cause o maior trabalho possvel necessrio para determinar a res-
posta nal.
Exemplo de uso de um orculo
Teorema: Qualquer algoritmo para encontrar o maior e o menor elementos de
um conjunto com n elementos no ordenados, n 1, faz pelo menos 3n/2|
2 comparaes.
Prova: A tcnica utilizada dene um orculo que descreve o comportamento
do algoritmo por meio de um conjunto de ntuplas, mais um conjunto de regras
associadas que mostram as tuplas possveis (estados) que um algoritmo pode
assumir a partir de uma dada tupla e uma nica comparao.
Uma 4tupla, representada por (a, b, c, d), onde os elementos de:
a nunca foram comparados;
b foram vencedores e nunca perderam em comparaes realizadas;
c foram perdedores e nunca venceram em comparaes realizadas;
d foram vencedores e perdedores em comparaes realizadas.
O algoritmo inicia no estado (n, 0, 0, 0) e termina com (0, 1, 1, n 2).
( , 0, 0, 0)
.
.
n (0, 1, 1, 2)
n
.
Aps cada comparao a tupla (a, b, c, d) consegue progredir apenas se ela
assume um dentre os seis estados possveis abaixo:
1. (a 2, b +1, c +1, d) se a 2
Dois elementos de a so comparados.
2. (a 1, b +1, c, d) ou
3. (a 1, b, c +1, d) ou
4. (a 1, b, c, d +1) se a 1
Um elemento de a comparado com um de b ou um de c.
5. (a, b 1, c, d +1) se b 2
Dois elementos de b so comparados.
6. (a, b, c 1, d +1) se c 2
Dois elementos de c so comparados.
O primeiro passo requer necessariamente a manipulao do componente a.
O caminho mais rpido para levar a at zero requer n/2| mudanas de es-
tado e termina com a tupla (0, n/2, n/2, 0) (por meio de comparao dos
elementos de a dois a dois).
A seguir, para reduzir o componente b at um so necessrias n/2|1 mu-
danas de estado (mnimo de comparaes necessrias para obter o maior
elemento de b).
Idem para c, com n/2| 1 mudanas de estado.
Logo, para obter o estado (0, 1, 1, n 2) a partir do estado (n, 0, 0, 0) so
necessrias
n/2| +n/2| 1 +n/2| 1 = 3n/2| 2
comparaes. 2
O teorema nos diz que se o nmero de comparaes entre os elementos de
um vetor for utilizado como medida de custo, ento o algoritmo MaxMin3
timo.
Comportamento assinttico de funes
O parmetro n fornece uma medida da diculdade para se resolver o proble-
ma.
Para valores sucientemente pequenos de n, qualquer algoritmo custa pouco
para ser executado, mesmo os inecientes.
A escolha do algoritmo no um problema crtico para problemas de
tamanho pequeno.
Logo, a anlise de algoritmos realizada para valores grandes de n.
Estuda-se o comportamento assinttico das funes de custo (comporta-
mento de suas funes de custo para valores grandes de n).
O comportamento assinttico de f(n) representa o limite do comportamento
do custo quando n cresce.
Dominao assinttica
A anlise de um algoritmo geralmente conta com apenas algumas operaes
elementares.
A medida de custo ou medida de complexidade relata o crescimento assin-
ttico da operao considerada.
Denio: Uma funo f(n) domina assintoticamente outra funo g(n)
se existem duas constantes positivas c e n
0
tais que, para n n
0
, temos
[g(n)[ c [f(n)[.
( ) g
cf n ( )
0
n
f , g
n
n
Exemplo:
Sejam g(n) = (n +1)
2
e f(n) = n
2
.
As funes g(n) e f(n) dominam assintoticamente
uma a outra, j que
[(n +1)
2
[ 4[n
2
[
para n 1 e
[n
2
[ [(n +1)
2
[
para n 0.
Como medir o custo de execuo de um algoritmo?
Funo de Custo ou Funo de Complexidade
f(n) = medida de custo necessrio para executar um algoritmo para um
problema de tamanho n.
Se f(n) uma medida da quantidade de tempo necessrio para executar
um algoritmo para um problema de tamanho n, ento f chamada funo
de complexidade de tempo de algoritmo.
Se f(n) uma medida da quantidade de memria necessria para exe-
cutar um algoritmo para um problema de tamanho n, ento f chamada
funo de complexidade de espao de algoritmo.
Observao: tempo no tempo!
importante ressaltar que a complexidade de tempo na realidade no re-
presenta tempo diretamente, mas o nmero de vezes que determinada op-
erao considerada relevante executada
Custo assinttico de funes
interessante comparar algoritmos para valores grandes de n.
O custo assinttico de uma funo f(n) representa o limite do comporta-
mento de custo quando n cresce.
Em geral, o custo aumenta com o tamanho n do problema.
Observao:
Para valores pequenos de n, mesmo um algoritmo ineciente no custa
muito para ser executado.
Notao assinttica de funes
Existem trs notaes principais na anlise assinttica de funes:
Notao
Notao O (O grande)
Notao
Notao
g
c
0
n
f , g
2
n
n
n
( )
( )
( )
c
n
g
f
1
f(n) = (g(n))
Notao
A notao limita a funo por fatores constantes.
Escreve-se f(n) = (g(n)), se existirem constantes positivas c
1
, c
2
e n
0
tais que para n n
0
, o valor de f(n) est sempre entre c
1
g(n) e c
2
g(n)
inclusive.
Neste caso, pode-se dizer que g(n) um limite assinttico rme (em ingls,
asymptotically tight bound) para f(n).
f(n) = (g(n)), c
1
> 0, c
2
> 0 e n
0
[
0 c
1
g(n) f(n) c
2
g(n), n n
0
g
c
0
n
f , g
2
n
n
n
( )
( )
( )
c
n
g
f
1
Notao : Exemplo
Mostre que
1
2
n
2
3n = (n
2
).
Para provar esta armao, devemos achar constantes c
1
> 0, c
2
> 0, n > 0,
tais que:
c
1
n
2
1
2
n
2
3n c
2
n
2
para todo n n
o
.
Se dividirmos a expresso acima por n
2
temos:
c
1

1
2

3
n
c
2
Notao : Exemplo
A inequao mais a direita ser sempre vlida para qualquer valor de n 1 ao
escolhermos c
2

1
2
.
Da mesma forma, a inequao mais a esquerda ser sempre vlida para qual-
quer valor de n 7 ao escolhermos c
1

1
14
.
Assim, ao escolhermos c
1
= 1/14, c
2
= 1/2 e n
0
= 7, podemos vericar que
1
2
n
2
3n = (n
2
).
Note que existem outras escolhas para as constantes c
1
e c
2
, mas o fato impor-
tante que a escolha existe.
Note tambm que a escolha destas constantes depende da funo
1
2
n
2
3n.
Uma funo diferente pertencente a (n
2
) ir provavelmente requerer outras
constantes.
Notao : Exemplo
Usando a denio formal de prove que 6n
3
,= (n
2
).
Notao O
c
n
f , g
n
n
( )
( )
n
f
g
0
f(n) = O(g(n))
Notao O
A notao O dene um limite superior para a funo, por um fator constante.
Escreve-se f(n) = O(g(n)), se existirem constantes positivas c e n
0
tais
que para n n
0
, o valor de f(n) menor ou igual a cg(n). Neste caso,
pode-se dizer que g(n) um limite assinttico superior (em ingls, asymptot-
ically upper bound) para f(n).
f(n) = O(g(n)), c > 0 e n
0
[ 0 f(n) cg(n), n n
0
Escrevemos f(n) = O(g(n)) para expressar que g(n) domina assintotica-
mente f(n). L-se f(n) da ordem no mximo g(n).
Notao O: Exemplos
Seja f(n) = (n +1)
2
.
Logo f(n) O(n
2
), quando n
0
= 1 e c = 4, j que
(n +1)
2
4n
2
para n 1.
Seja f(n) = n e g(n) = n
2
. Mostre que g(n) no O(n).
Sabemos que f(n) O(n
2
), pois para n 0, n n
2
.
Suponha que existam constantes c e n
0
tais que para todo n n
0
, n
2
cn. Assim, c n para qualquer n n

0
. No entanto, no existe uma
constante c que possa ser maior ou igual a n para todo n.
Notao O: Exemplos
Mostre que g(n) = 3n
3
+2n
2
+n O(n
3
).
Basta mostrar que 3n
3
+2n
2
+n 6n
3
, para n 0.
A funo g(n) = 3n
3
+ 2n
2
+ n tambm O(n
4
), entretanto esta ar-
mao mais fraca do que dizer que g(n) O(n
3
).
Mostre que h(n) = log
5
n O(logn).
O log
b
n difere do log
c
n por uma constante que no caso log
b
c.
Como n = c
log
c
n
, tomando o logaritmo base b em ambos os lados da
igualdade, temos que log
b
n = log
b
c
log
c
n
= log
c
n log
b
c.
Notao O
Quando a notao O usada para expressar o tempo de execuo de um
algoritmo no pior caso, est se denindo tambm o limite (superior) do tempo
de execuo desse algoritmo para todas as entradas.
Por exemplo, o algoritmo de ordenao por insero (a ser estudado neste
curso) O(n
2
) no pior caso.
Este limite se aplica para qualquer entrada.
Notao O
Tecnicamente um abuso dizer que o tempo de execuo do algoritmo de
ordenao por insero O(n
2
) (i.e., sem especicar se para o pior caso,
melhor caso, ou caso mdio)
O tempo de execuo desse algoritmo depende de como os dados de
entrada esto arranjados.
Se os dados de entrada j estiverem ordenados, este algoritmo tem um
tempo de execuo de O(n), ou seja, o tempo de execuo do algoritmo
de ordenao por insero no melhor caso O(n).
O que se quer dizer quando se fala que o tempo de execuo O(n
2
)
que no pior caso o tempo de execuo O(n
2
).
Ou seja, no importa como os dados de entrada esto arranjados, o tempo
de execuo em qualquer entrada O(n
2
).
Operaes com a notao O
f(n) = O(f(n))
c O(f(n)) = O(f(n)) c = constante
O(f(n)) +O(f(n)) = O(f(n))
O(O(f(n)) = O(f(n))
O(f(n)) +O(g(n)) = O(max(f(n), g(n)))
O(f(n))O(g(n)) = O(f(n)g(n))
f(n)O(g(n)) = O(f(n)g(n))
Operaes com a notao O: Exemplos
Regra da soma O(f(n)) +O(g(n)).
Suponha trs trechos cujos tempos de execuo so
O(n), O(n
2
) e O(nlogn).
O tempo de execuo dos dois primeiros trechos O(max(n, n
2
)), que
O(n
2
).
O tempo de execuo de todos os trs trechos ento
O(max(n
2
, nlogn)),
que O(n
2
).
O produto de [logn +k +O(1/n)] por [n +O(
n)]
nlogn +kn +O(
nlogn).
Notao
c
n
f , g
n
n
( )
( )
n
g
f
0
f(n) = (g(n))
Notao
A notao dene um limite inferior para a funo, por um fator constante.
Escreve-se f(n) = (g(n)), se existirem constantes positivas c e n
0
tais
que para n n
0
, o valor de f(n) maior ou igual a cg(n).
Pode-se dizer que g(n) um limite assinttico inferior (em ingls, asymp-
totically lower bound) para f(n).
f(n) = (g(n)), c > 0 e n
0
[ 0 cg(n) f(n), n n
0
Notao
Quando a notao usada para expressar o tempo de execuo de um al-
goritmo no melhor caso, est se denindo tambm o limite (inferior) do tempo
de execuo desse algoritmo para todas as entradas.
Por exemplo, o algoritmo de ordenao por insero (n) no melhor
caso.
O tempo de execuo do algoritmo de ordenao por insero (n).
O que signica dizer que o tempo de execuo (i.e., sem especicar se
para o pior caso, melhor caso, ou caso mdio) (g(n))?
O tempo de execuo desse algoritmo pelo menos uma constante vezes
g(n) para valores sucientemente grandes de n.
Notao : Exemplos
Para mostrar que f(n) = 3n
3
+ 2n
2
(n
3
) basta fazer c = 1, e ento
3n
3
+2n
2
n
3
para n 0.
Seja f(n) = n para n mpar (n 1) e f(n) = n
2
/10 para n par (n
0).
Neste caso f(n) (n
2
), bastando considerar c = 1/10 e n =
0, 2, 4, 6, . . .
Limites do algoritmo de ordenao por insero
O tempo de execuo do algoritmo de ordenao por insero est entre
(n) e O(n
2
).
Estes limites so assintoticamente os mais rmes possveis.
Por exemplo, o tempo de execuo deste algoritmo no (n
2
), pois o
algoritmo executa em tempo (n) quando a entrada j est ordenada.
No contraditrio dizer que o tempo de execuo deste algoritmo no pior
caso (n
2
), j que existem entradas para este algoritmo que fazem com
que ele execute em tempo (n
2
).
Teorema
Para quaisquer funes f(n) e g(n),
f(n) = (g(n))
se e somente se,
f(n) = O(g(n)), e
f(n) = (g(n))
Mais sobre notao assinttica de funes
Existem duas outras notaes na anlise assinttica de funes:
Notao o (O pequeno)
Notao
Estas duas notaes no so usadas normalmente, mas importante saber
seus conceitos e diferenas em relao s notaes O e , respectivamente.
Notao o
O limite assinttico superior denido pela notao O pode ser assintotica-
mente rme ou no.
Por exemplo, o limite 2n
2
= O(n
2
) assintoticamente rme, mas o limite
2n = O(n
2
) no .
A notao o usada para denir um limite superior que no assintotica-
mente rme.
Formalmente a notao o denida como:
f(n) = o(g(n)), para qq c > 0 e n
0
[ 0 f(n) < cg(n), n n
0
Exemplo, 2n = o(n
2
) mas 2n
2
,= o(n
2
).
Notao o
As denies das notaes O (o grande) e o (o pequeno) so similares.
A diferena principal que em f(n) = O(g(n)), a expresso 0 f(n)
cg(n) vlida para todas constantes c > 0.
Intuitivamente, a funo f(n) tem um crescimento muito menor que g(n)
quando n tende para innito. Isto pode ser expresso da seguinte forma:
lim
n
f(n)
g(n)
= 0
Alguns autores usam este limite como a denio de o.
Notao
Por analogia, a notao est relacionada coma notao da mesma forma
que a notao o est relacionada com a notao O.
Formalmente a notao denida como:
f(n) = (g(n)), para qq c > 0 e n
0
[ 0 cg(n) < f(n), n n
0
Por exemplo,
n
2
2
= (n), mas
n
2
2
,= (n
2
).
A relao f(n) = (g(n)) implica em
lim
n
f(n)
g(n)
= ,
se o limite existir.
Comparao de programas
Podemos avaliar programas comparando as funes de complexidade, negli-
genciando as constantes de proporcionalidade.
Um programa com tempo de execuo O(n) melhor que outro com tempo
O(n
2
).
Porm, as constantes de proporcionalidade podem alterar esta consider-
ao.
Exemplo: um programa leva 100n unidades de tempo para ser executado e
outro leva 2n
2
. Qual dos dois programas melhor?
Depende do tamanho do problema.
Para n < 50, o programa com tempo 2n
2
melhor do que o que possui
tempo 100n.
Para problemas com entrada de dados pequena prefervel usar o pro-
grama cujo tempo de execuo O(n
2
).
Entretanto, quando n cresce, o programa com tempo de execuo O(n
2
)
leva muito mais tempo que o programa O(n).
Classes de Comportamento Assinttico
Complexidade Constante
f(n) = O(1)
O uso do algoritmo independe do tamanho de n.
As instrues do algoritmo so executadas um nmero xo de vezes.
O que signica um algoritmo ser O(2) ou O(5)?
Complexidade Logartmica
f(n) = O(logn)
Ocorre tipicamente em algoritmos que resolvem um problema transfor-
mando-o em problemas menores.
Nestes casos, o tempo de execuo pode ser considerado como sendo
menor do que uma constante grande.
Supondo que a base do logaritmo seja 2:
Para n = 1000, log
2
10.
Para n = 1000000, log
2
20.
Exemplo:
Algoritmo de pesquisa binria.
Complexidade Linear
f(n) = O(n)
Em geral, um pequeno trabalho realizado sobre cada elemento de en-
trada.
Esta a melhor situao possvel para um algoritmo que tem que proces-
sar/produzir n elementos de entrada/sada.
Cada vez que n dobra de tamanho, o tempo de execuo tambm dobra.
Exemplos:
Algoritmo de pesquisa seqencial.
Algoritmo para teste de planaridade de um grafo.
Complexidade Linear Logartmica
f(n) = O(nlogn)
Este tempo de execuo ocorre tipicamente em algoritmos que resolvem
um problema quebrando-o em problemas menores, resolvendo cada um
deles independentemente e depois agrupando as solues.
Caso tpico dos algoritmos baseados no paradigma diviso-e-conquista.
Supondo que a base do logaritmo seja 2:
Para n = 1000000, log
2
20000000.
Para n = 2000000, log
2
42000000.
Exemplo:
Algoritmo de ordenao MergeSort.
Complexidade Quadrtica
f(n) = O(n
2
)
Algoritmos desta ordem de complexidade ocorrem quando os itens de da-
dos so processados aos pares, muitas vezes em um anel dentro do outro
Para n = 1000, o nmero de operaes da ordem de 1000000.
Sempre que n dobra o tempo de execuo multiplicado por 4.
Algoritmos deste tipo so teis para resolver problemas de tamanhos rela-
tivamente pequenos.
Exemplos:
Algoritmos de ordenao simples como seleo e insero.
Complexidade Cbica
f(n) = O(n
3
)
Algoritmos desta ordem de complexidade geralmente so teis apenas
para resolver problemas relativamente pequenos.
Para n = 100, o nmero de operaes da ordem de 1000000
Sempre que n dobra o tempo de execuo multiplicado por 8.
Algoritmos deste tipo so teis para resolver problemas de tamanhos rela-
tivamente pequenos.
Exemplo:
Algoritmo para multiplicao de matrizes.
Complexidade Exponencial
f(n) = O(2
n
)
Algoritmos desta ordem de complexidade no so teis sob o ponto de
vista prtico.
Eles ocorrem na soluo de problemas quando se usa a fora bruta para
resolv-los.
Para n = 20, o tempo de execuo cerca de 1000000.
Sempre que n dobra o tempo de execuo ca elevado ao quadrado.
Exemplo:
Algoritmo do Caixeiro Viajante
Complexidade Exponencial
f(n) = O(n!).
Um algoritmo de complexidade O(n!) dito ter complexidade exponencial,
apesar de O(n!) ter comportamento muito pior do que O(2
n
).
Geralmente ocorrem quando se usa fora bruta na soluo do problema.
Considerando:
n = 20, temos que 20! = 2432902008176640000, um nmero com 19
dgitos.
n = 40 temos um nmero com 48 dgitos.
Comparao de funes de complexidade
Funo Tamanho n
de custo 10 20 30 40 50 60
n
0,00001 0,00002 0,00003 0,00004 0,00005 0,00006
s s s s s s
n
2 0,0001 0,0004 0,0009 0,0016 0,0.35 0,0036
s s s s s s
n
3 0,001 0,008 0,027 0,64 0,125 0.316
s s s s s s
n
5 0,1 3,2 24,3 1,7 5,2 13
s s s min min min
2
n 0,001 1 17,9 12,7 35,7 366
s s min dias anos s
3
n 0,059 58 6,5 3855 10
8
10
13
s min anos s s s
Funo de Computador Computador 100 Computador 1000
custo de tempo atual vezes mais rpido vezes mais rpido
n t
1
100 t
1
1000 t
1
n
2
t
2
10 t
2
31, 6 t
2
n
3
t
3
4, 6 t
3
10 t
3
2
n
t
4
t
4
+6, 6 t
4
+10
Hierarquias de funes
A seguinte hierarquia de funes pode ser denida do ponto de vista assinttico:
1 loglogn logn n
n
c
n
logn
c
n
n
n
c
c
n
onde e c so constantes arbitrrias com 0 < < 1 < c.
Hierarquias de funes: Exerccio 1
Usando MatLab, ou um outro pacote matemtico, desenhe os grcos dessas
funes, quando n
Hierarquias de funes: Exerccio 2
Onde as seguintes funes se encaixam nessa hierarquia? (Mostre a sua
soluo)
(a) (n) =
n
lnn
. Esta funo dene o nmero de primos menor ou igual a n.
(b) e
logn
.
Dica: e
f(n)
e
g(n)
lim
n
(f(n) g(n)) =
Hierarquias de Funes
Preliminares
A hierarquia apresentada est relacionada com funes que vo para o innito.
No entanto, podemos ter o recproco dessas funes j que elas nunca so
zero. Isto ,
f(n) g(n)
1
g(n)

1
f(n)
.
Assim, todas as funes (exceto 1) tendem para zero:
1
c
c
n

1
n
n

1
c
n

1
n
logn

1
n
c

1
n

1
logn
1
loglogn
1
Soluo de (a)
(n) =
n
lnn
Temos que (note que a base do logaritmo no altera a hierarquia):
1
n

1
lnn
1
Multiplicando por n, temos:
n
n

n
lnn
n,
ou seja,
n
1
(n) n
Note que o valor 1 ainda menor que 1.
Soluo de (b)
e
logn
Dado a hierarquia:
1 lnlnn
lnn lnn
e elevando a e, temos que:
e
1
e
lnlnn
e
lnn
e
lnn
Simplicando temos:
e lnn e
lnn
n

Algoritmo exponencial Algoritmo polinomial
Funes de complexidade:
Um algoritmo cuja funo de complexidade O(c
n
), c > 1, chamado de
algoritmo exponencial no tempo de execuo.
Um algoritmo cuja funo de complexidade O(p(n)), onde p(n) um
polinmio de grau n, chamado de algoritmo polinomial no tempo de exe-
cuo.
A distino entre estes dois tipos de algoritmos torna-se signicativa quando
o tamanho do problema a ser resolvido cresce.
Esta a razo porque algoritmos polinomiais so muito mais teis na prtica
do que algoritmos exponenciais.
Geralmente, algoritmos exponenciais so simples variaes de pesquisa
exaustiva.
Algoritmo exponencial Algoritmo polinomial
Os algoritmos polinomiais so geralmente obtidos atravs de um entendi-
mento mais profundo da estrutura do problema.
Tratabilidade dos problemas:
Um problema considerado intratvel se ele to difcil que no se conhe-
ce um algoritmo polinomial para resolv-lo.
Um problema considerado tratvel (bem resolvido) se existe um algoritmo
polinomial para resolv-lo.
Aspecto importante no projeto de algoritmos.
Algoritmos polinomiais Algoritmos exponenciais
A distino entre algoritmos polinomiais ecientes e algoritmos exponenciais
inecientes possui vrias excees.
Exemplo: um algoritmo com funo de complexidade f(n) = 2
n
mais
rpido que um algoritmo g(n) = n
5
para valores de n menores ou iguais a
20.
Tambm existem algoritmos exponenciais que so muito teis na prtica.
Exemplo: o algoritmo Simplex para programao linear possui complexi-
dade de tempo exponencial para o pior caso mas executa muito rpido na
prtica.
Tais exemplos no ocorrem com freqncia na prtica, e muitos algoritmos
exponenciais conhecidos no so muito teis.
Algoritmo exponencial
O Problema do Caixeiro Viajante
Um caixeiro viajante deseja visitar n cidades de tal forma que sua viagem
inicie e termine em uma mesma cidade, e cada cidade deve ser visitada uma
nica vez.
Supondo que sempre h uma estrada entre duas cidades quaisquer, o prob-
lema encontrar a menor rota para a viagem.
Seja a gura que ilustra o exemplo para quatro cidades c
1
, c
2
, c
3
, c
4
, em que
os nmeros nas arestas indicam a distncia entre duas cidades.
8
5
4
8
3
c
1
c
c
c
2
3
4
9
O percurso c
1
, c
3
, c
4
, c
2
, c
1
) uma soluo
para o problema, cujo percurso total tem distn-
cia 24.
Exemplo de algoritmo exponencial
Um algoritmo simples seria vericar todas as rotas e escolher a menor delas.
H (n1)! rotas possveis e a distncia total percorrida em cada rota envolve
n adies, logo o nmero total de adies n!.
No exemplo anterior teramos 24 adies.
Suponha agora 50 cidades: o nmero de adies seria 50! 10
64
.
Em um computador que executa 10
9
adies por segundo, o tempo total para
resolver o problema com 50 cidades seria maior do que 10
45
sculos s para
executar as adies.
O problema do caixeiro viajante aparece com freqncia em problemas rela-
cionados com transporte, mas tambm aplicaes importantes relacionadas
com otimizao de caminho percorrido.
Tcnicas de anlise de algoritmos
Determinar o tempo de execuo de um programa pode ser um problema
matemtico complexo.
Determinar a ordem do tempo de execuo, sem preocupao com o valor da
constante envolvida, pode ser uma tarefa mais simples.
A anlise utiliza tcnicas de matemtica discreta, envolvendo contagem ou
enumerao dos elementos de um conjunto:
manipulao de somas;
produtos;
permutaes;
fatoriais;
coecientes binomiais;
soluo de equaes de recorrncia.
Anlise do tempo de execuo
Comando de atribuio, de leitura ou de escrita: O(1).
Seqncia de comandos: determinado pelo maior tempo de execuo de
qualquer comando da seqncia.
Comando de deciso: tempo dos comandos dentro do comando condicional,
mais tempo para avaliar a condio, que O(1).
Anel: soma do tempo de execuo do corpo do anel mais o tempo de avaliar
a condio para terminao (geralmente O(1)), multiplicado pelo nmero de
iteraes.
Anlise do tempo de execuo
Procedimentos no recursivos:
Cada um deve ser computado separadamente um a um, iniciando com os
que no chamam outros procedimentos.
Avalia-se ento os que so chamam os j avaliados (utilizando os tempos
desses).
O processo repetido at chegar no programa principal.
Procedimentos recursivos:
associada uma funo de complexidade f(n) desconhecida, onde n
mede o tamanho dos argumentos.
Procedimento no recursivo
Algoritmo para ordenar os n elementos de um conjunto A em ordem ascen-
dente.
procedure Ordena (var A: Vetor);
var i, j, min, x: integer;
begin
(1) for i := 1 to n-1 do
begin
{min contm o ndice do
menor elemento de A[i..n]}
(2) min := i;
(3) for j := i+1 to n do
(4) if A[j] < A[min]
(5) then min := j;
{Troca A[min] e A[i]}
(6) x := A[min];
(7) A[min] := A[i];
(8) A[i] := x;
end;
end;
Seleciona o menor elemento do conjunto.
Troca este elemento com A[1].
Repete as duas operaes acima com os n 1
elementos restantes, depois com os n 2, at
que reste apenas um.
Anlise do procedimento no recursivo
Anel interno
Contm um comando de deciso, com um comando apenas de atribuio.
Ambos levam tempo constante para serem executados.
Quanto ao corpo do comando de deciso, devemos considerar o pior caso,
assumindo que ser sempre executado.
O tempo para incrementar o ndice do anel e avaliar sua condio de termi-
nao O(1).
O tempo combinado para executar uma vez o anel O(max(1, 1, 1)) =
O(1), conforme regra da soma para a notao O.
Como o nmero de iteraes ni, o tempo gasto no anel O((ni)1) =
O(n i), conforme regra do produto para a notao O.
Anlise do procedimento no recursivo
Anel externo
Contm, alm do anel interno, quatro comandos de atribuio:
O(max(1, (n i), 1, 1, 1)) = O(n i).
A linha (1) executada n1 vezes, e o tempo total para executar o programa
est limitado ao produto de uma constante pelo somatrio de (n i):

n1
1
(n i) =
n(n1)
2
=
n
2
2

n
2
= O(n
2
)
Considerarmos o nmero de comparaes como a medida de custo relevante,
o programa faz (n
2
)/2 n/2 comparaes para ordenar n elementos.
Considerarmos o nmero de trocas, o programa realiza exatamente n 1
trocas.
Algoritmos recursivos
Umobjeto recursivo quando denido parcialmente emtermos de si mesmo
Exemplo 1: Nmeros naturais
(a) 1 um nmero natural
(b) o sucessor de um nmero natural um nmero natural
Exemplo 2: Funo fatorial
(a) 0! = 1
(b) se n > 0 ento n! = n (n 1)!
Algoritmos recursivos
Exemplo 3: rvores
(a) A rvore vazia uma rvore
(b) se T
1
e T
2
so rvores ento T
t
um rvore
T
t
T
1
T
2

Poder da recurso
Denir um conjunto innito de objetos atravs de um comando nito
Um problema recursivo P pode ser expresso como P 1[S
i
, P], onde 1
a composio de comandos S
i
e do prprio P
Importante: constantes e variveis locais a P so duplicadas a cada chamada
recursiva
Problema de terminao
Denir um condio de terminao
Idia:
Associar um parmetro, por exemplo n, com P e chamar P recursivamente
com n 1 como parmetro
A condio n > 0 garante a terminao
Exemplo:
P(n) if n > 0 then 1[S
i
; P(n 1)]
Importante: na prtica necessrio:
mostrar que o nvel de recurso nito, e
tem que ser mantido pequeno! Por que?
Razes para limitar a recurso
Memria necessria para acomodar variveis a cada chamada
O estado corrente da computao tem que ser armazenado para permitir a
volta da chamada recursiva.
Exemplo:
function F(i : integer) : integer;
begin
if i > 0
then F := i
*
F(i-1)
else F := 1;
end;
F(4) 1 4F(3)
2 3F(2)
3 2F(1)
4 1F(0)
1
Quando no usar recursividade
Algoritmos recursivos so apropriados quando o problema denido em ter-
mos recursivos
Entretanto, uma denio recursiva no implica necessariamente que a im-
plementao recursiva a melhor soluo!
Casos onde evitar recursividade:
P if condio then (S
i
; P)
Exemplo: P if i < n then (
..
i := i +1; F := i F; P)
Eliminando a recursidade de cauda
(Tail recursion)
function Fat : integer;
var F, i : integer;
begin
i := 0; F := 1;
while i < n do
begin
i := i+1;
F := F
*
i;
end;
Fat := F;
end
Logo,
P if B then (S; P)
deve ser transformado em
P (x = x
0
; while B do S)
Outro exemplo
function Fib(n : integer) : integer;
begin
if n = 0
then Fib := 0
else if n = 1
then Fib := 1
else Fib := Fib(n-1) + Fib(n-2);
end; {Fib}
Observao: para cada chamada a
Fib(n), Fib ativada 2 vezes
5
s
4
s
3
s
2
s
1
s
f
f
f
f
f
ff
0
s
f
f
f
f
f
ff
1
s
t
t
t
t
t
tt
2
s
1
s
f
f
f
f
f
ff
0
s
D
D
D
D
D
D
D
Dl
l
l
l
l
l
l
l
3
s
2
s
1
s
f
f
f
f
f
ff
0
s
f
f
f
f
f
ff
1
s
Soluo bvia
function Fib : integer;
var i, Temp, F, Fant : integer;
begin
i := 1; F := 1; Fant := 0;
while i < n do
begin
Temp := F;
F := F + Fant;
Fant := Temp;
i := i+1;
end;
Fib := F;
end; {Fib}
Complexidade de tempo: T(n) = n 1
Complexidade de espao: E(n) = O(1)
Procedimento recursivo
Pesquisa(n);
(1) if n 1
(2) then "inspecione elemento" e termine
else begin
(3) para cada um dos n elementos "inspecione elemento";
(4) Pesquisa(n/3);
end;
Para cada procedimento recursivo associada uma funo de complexidade
f(n) desconhecida, onde n mede o tamanho dos argumentos para o proce-
dimento.
Obtemos uma equao de recorrncia para f(n).
Equao de recorrncia: maneira de denir uma funo por uma expresso
envolvendo a mesma funo.
Anlise do procedimento recursivo
Seja T(n) uma funo de complexidade que represente o nmero de inspe-
es nos n elementos do conjunto.
O custo de execuo das linhas (1) e (2) O(1) e da linha (3) O(n).
Usa-se uma equao de recorrncia para determinar o n
o
de chamadas
recursivas.
O termo T(n) especicado em funo dos termos anteriores T(1), T(2),
. . ., T(n 1).
T(n) = n +T(n/3), T(1) = 1 (para n = 1 fazemos uma inspeo).
Por exemplo, T(3) = T(3/3)+3 = 4, T(9) = T(9/3)+9 = 13, e assim
por diante.
Para calcular o valor da funo seguindo a denio so necessrios k 1
passos para computar o valor de T(3
k
).
Exemplo de resoluo de equao de recorrncia
Substitui-se os termos T(k), k < n, at que todos os termos T(k), k > 1,
tenham sido substitudos por frmulas contendo apenas T(1).
T(n) = n +T(n/3)
T(n/3) = n/3 +T(n/3/3)
T(n/3/3) = n/3/3 +T(n/3/3/3)
.
.
.
T(n/3/3 /3) = n/3/3 /3 +T(n/3 /3)
Adicionando lado a lado, temos
T(n) = n +n (1/3) +n (1/3
2
) +n (1/3
3
) + +(n/3/3 /3)
que representa a soma de uma srie geomtrica de razo 1/3, multiplicada por
n, e adicionada de T(n/3/3 /3), que menor ou igual a 1.
T(n) = n +n (1/3) +n (1/3
2
) +n (1/3
3
) + + +(n/3/3 /3)
Se desprezarmos o termo T(n/3/3 /3), quando n tende para innito, ento
T(n) = n
i=0
(1/3)
i
= n
_
_
1
1
1
3
_
_
=
3n
2

Se considerarmos o termo T(n/3/3/3 /3) e denominarmos x o nmero de
subdivises por 3 do tamanho do problema, ento n/3
x
= 1, e n = 3
x
. Logo
x = log
3
n.
Lembrando que T(1) = 1 temos
T(n) =
x1
i=0
n
3
i
+T(
n
3
x
)
= n
x1
i=0
(1/3)
i
+1
=
n(1 (
1
3
)
x
)
(1
1
3
)
+1
=
3n
2

1
2

Logo, o programa do exemplo O(n).
Comentrios sobre recursividade
Evitar o uso de recursividade quando existe uma soluo bvia por iterao!
Exemplos:
Fatorial
Srie de Fibonacci
Anlise de algoritmos recursivos
Comportamento descrito por uma equao de recorrncia
Enfoque possvel:
Usar a prpria recorrncia para substituir para T(m), m < n at que todos
os termos tenham sido substitudos por frmulas envolvendo apenas T(0)
ou o caso base
Anlise da funo fat
Seja a seguinte funo para calcular o fatorial de n:
function fat(n : integer}) : integer};
begin
if n <= 1
then fat := 1
else fat := n
*
fat(n-1);
end; {fat}
Seja a seguinte equao de recorrncia para esta funo:
T(n) =
_
d n = 1
c +T(n 1) n > 1
Esta equao diz que quando n = 1 o custo para executar fat igual a d.
Para valores de n maiores que 1, o custo para executar fat c mais o custo
para executar T(n 1)
Resolvendo a equao de recorrncia
Esta equao de recorrncia pode ser
expressa da seguinte forma:
T(n) = c +T(n 1)
= c +(c +T(n 2))
= c +c +(c +T(n 3))
.
.
. =
.
.
.
= c +c + +(c +T(1))
= c +c + +c
. .
n1
+d
Em cada passo, o valor do termo T
substitudo pela sua denio (ou
seja, esta recorrncia est sendo re-
solvida pelo mtodo da expanso). A
ltima equao mostra que depois da
expanso existem n 1 cs, corre-
spondentes aos valores de 2 at n.
Desta forma, a recorrncia pode ser
expressa como:
T(n) = c(n 1) +d = O(n)
Alguns somatrios teis
n
i=1
i =
n(n +1)
2
k
i=0
2
k
= 2
k+1
1
k
i=0
1
2
i
= 2
1
2
k
k
i=0
a
i
=
a
k+1
1
a 1
(a ,= 1)
n
i=1
i
2
=
n(n +1)(2n +1)
6
Algumas recorrncias bsicas: Caso 1
T(n) = T(
n
2
) +1 (n 2)
T(1) = 0 (n = 1)
Vamos supor que:
n = 2
k
k = logn
Resolvendo por expanso temos:
T(2
k
) = T(2
k1
) +1
= (T(2
k2
) +1) +1
= (T(2
k3
) +1) +1 +1
.
.
.
.
.
.
= (T(2) +1) +1 + +1
= (T(1) +1) +1 + +1
= 0 +1 + +1
. .
k
= k
T(n) = logn
T(n) = O(logn)
Algumas recorrncias bsicas: Caso 2
T(n) = 2T(
n
2
) +n (n 2)
T(1) = 0 (n = 1)
Vamos supor que n = 2
k
k = logn. Resolvendo por expanso temos:
T(2
k
) = 2T(2
k1
) +2
k
= 2(2T(2
k2
) +2
k1
) +2
k
= 2(2(2T(2
k3
) +2
k2
) +2
k1
) +2
k
.
.
.
.
.
.
= 2(2( (2(2T(1) +2
2
) +2
3
) + ) +2
k1
) +2
k
= (k 1)2
k
+2
k
= k2
k
T(n) = nlogn
T(n) = O(nlogn)
Teorema Mestre
Recorrncias da forma
T(n) = aT(n/b) +f(n),
onde a 1 e b > 1 so constantes e f(n) uma funo assintoticamente pos-
itiva podem ser resolvidas usando o Teorema Mestre. Note que neste caso no
estamos achando a forma fechada da recorrncia mas sim seu comportamento
assinttico.
Teorema Mestre
Sejam as constantes a 1 e b > 1 e f(n) uma funo denida nos inteiros
no-negativos pela recorrncia:
T(n) = aT(n/b) +f(n),
onde a frao n/b pode signicar ]n/b| ou n/b|. A equao de recorrncia
T(n) pode ser limitada assintoticamente da seguinte forma:
1. Se f(n) = O(n
log
b
a
) para alguma constante > 0,
ento T(n) = (n
log
b
a
) .
2. Se f(n) = (n
log
b
a
), ento T(n) = (n
log
b
a
logn) .
3. Se f(n) = (n
log
b
a+
) para alguma constante > 0 e se af(n/b)
cf(n) para alguma constante c < 1 e para n sucientemente grande,
ento T(n) = (f(n)) .
Comentrios sobre o teorema Mestre
Nos trs casos estamos comparando a funo f(n) com a funo n
log
b
a
.
Intuitivamente, a soluo da recorrncia determinada pela maior das duas
funes.
Por exemplo:
No primeiro caso a funo n
log
b
a
a maior e a soluo para a recorrncia
T(n) = (n
log
b
a
).
No terceiro caso, a funo f(n) a maior e a soluo para a recorrncia
T(n) = (f(n)).
No segundo caso, as duas funes so do mesmo tamanho. Neste caso,
a soluo ca multiplicada por um fator logartmico e ca da forma T(n) =
(n
log
b
a
logn) = (f(n) logn).
Tecnicalidades sobre o teorema Mestre
No primeiro caso, a funo f(n) deve ser no somente menor que n
log
b
a
mas ser polinomialmente menor. Ou seja, f(n) deve ser assintoticamente
menor que n
log
b
a
por um fator de n
, para alguma constante > 0.

No terceiro caso, a funo f(n) deve ser no somente maior que n
log
b
a
mas ser polinomialmente maior e satisfazer a condio de regularidade que
af(n/b) cf(n). Esta condio satisfeita pela maior parte das funes
polinomiais encontradas neste curso.
Tecnicalidades sobre o teorema Mestre
Teorema no cobre todas as possibilidades para f(n):
Entre os casos 1 e 3 existem funes f(n) que so menores que n
log
b
a
mas no so polinomialmente menores.
Entre os casos 2 e 3 existem funes f(n) que so maiores que n
log
b
a
mas no so polinomialmente maiores.
Se a funo f(n) cai numa dessas condies ou a condio de regularidade
do caso 3 falsa, ento no se pode aplicar este teorema para resolver a
recorrncia.
Uso do teorema: Exemplo 1
T(n) = 9T(n/3) +n
Temos que,
a = 9, b = 3, f(n) = n
Desta forma,
n
log
b
a
= n
log
3
9
= (n
2
)
Como f(n) = O(n
log
3
9
), onde = 1, podemos aplicar o caso 1 do teorema
e concluir que a soluo da recorrncia
T(n) = (n
2
)
T(n) = T(2n/3) +1
Temos que,
a = 1, b = 3/2, f(n) = 1
Desta forma,
n
log
b
a
= n
log
3/2
1
= n
0
= 1
O caso 2 se aplica j que f(n) = (n
log
b
a
) = (1). Temos, ento, que a
soluo da recorrncia
T(n) = (logn)
T(n) = 3T(n/4) +nlogn
Temos que,
a = 3, b = 4, f(n) = nlogn
Desta forma,
n
log
b
a
= n
log
4
3
= O(n
0.793
)
Como f(n) = (n
log
4
3+
), onde 0.2, o caso 3 se aplica se mostrarmos
que a condio de regularidade verdadeira para f(n).
Para um valor sucientemente grande de n
af(n/b) = 3(n/4) log(n/4) (3/4)nlogn = cf(n)
para c = 3/4. Conseqentemente, usando o caso 3, a soluo para a recor-
rncia
T(n) = (nlogn)
T(n) = 2T(n/2) +nlogn
Temos que,
a = 2, b = 2, f(n) = nlogn
Desta forma,
n
log
b
a
= n
Aparentemente o caso 3 deveria se aplicar j que f(n) = nlogn assintoti-
camente maior que n
log
b
a
= n. Mas no entanto, no polinomialmente maior.
A frao f(n)/n
log
b
a
= (nlogn)/n = logn que assintoticamente menor
que n
para toda constante positiva . Conseqentemente, a recorrncia cai na

situao entre os casos 2 e 3 onde o teorema no pode ser aplicado.
Uso do teorema: Exerccio 5
T(n) = 4T(n/2) +n
T(n) = 4T(n/2) +n
2
T(n) = 4T(n/2) +n
3
O tempo de execuo de um algoritmo A descrito pela recorrncia
T(n) = 7T(n/2) +n
2
Um outro algoritmo A
t
tem um tempo de execuo descrito pela recorrncia
T
t
(n) = aT
t
(n/4) +n
2
Qual o maior valor inteiro de a tal que A
t
assintoticamente mais rpido que
A?
Notao assinttica em funes
Normalmente, a notao assinttica usada em frmulas matemticas. Por
exemplo, usando a notao O pode-se escrever que n = O(n
2
). Tambm
pode-se escrever que
2n
2
+3n +1 = 2n
2
+(n)
Como se interpreta uma frmula como esta?
Notao assinttica sozinha no lado direito de uma equao, como em n =
O(n
2
)
Sinal de igualdade signica que o lado esquerdo um membro do conjunto
O(n
2
)
n O(n
2
) ou n n
2
Nunca deve-se escrever uma igualdade onde a notao O aparece sozinha
com os lados trocados
Caso contrrio, poderia se deduzir um absurdo como n
2
= n de igual-
dades como em O(n
2
) = n
Quando se trabalha com a notao O e em qualquer outra frmula que en-
volve quantidades no precisas, o sinal de igualdade unidirecional
Da vem o fato que o sinal de igualdade ("=") realmente signica ou ,
usados para incluso de conjuntos
Se uma notao assinttica aparece numa frmula, isso signica que essa no-
tao est substituindo uma funo que no importante denir precisamente
(por algum motivo). Por exemplo, a equao
2n
2
+3n +1 = 2n
2
+(n)
signica que
2n
2
+3n +1 = 2n
2
+f(n)
onde f(n) alguma funo no conjunto (n). Neste caso, f(n) = 3n + 1
que de fato est em (n).
O uso da notao assinttica desta forma ajuda a eliminar detalhes que no
so importantes. Por exemplo, pode-se expressar uma equao de recorrncia
como:
T(n) = 2T(n 1) +(n).
Se se deseja determinar o comportamento assinttico de T(n) ento no
necessrio determinar exatamente os termos de mais baixa ordem. Entende-se
que eles esto includos numa funo f(n) expressa no termo (n).
Em alguns casos, a anotao assinttica aparece do lado esquerdo de uma
equao como em:
2n
2
+(n) = (n
2
).
A interpretao de tais equaes deve ser feita usando a seguinte regra:
possvel escolher uma funo f(n) para o lado esquerdo da igualdade de
tal forma que existe uma funo g(n) para o lado direito que faz com que a
equao seja vlida
O lado direito da igualdade dene um valor no to preciso quanto o lado
esquerdo. Por exemplo,
2n
2
+3n +1 = 2n
2
+(n) (1)
2n
2
+(n) = (n
2
). (2)
As equaes (1) e (2) podem ser interpretadas usando a regra acima:
A equao (1) diz que existe alguma funo f(n) (n) tal que 2n
2
+
3n +1 = 2n
2
+f(n) para todo n.
A equao (2) diz que para qualquer funo g(n) (n), existe uma funo
h(n) (n
2
) tal que
2n
2
+g(n) = h(n)
para todo n. Note que esta interpretao implica que 2n
2
+3n+1 = (n
2
),
que o que estas duas equaes querem dizer.
Modelagem usando equao de recorrncia
Torre de Hanoi
Inventor:
Em 1883, o matemtico francs Edouard Lucas criou um jogo chamado
Torre de Hanoi
Congurao inicial:
O jogo comea com um conjunto de oito discos empilhados em tamanho
decrescente em uma das trs varetas
Torre de Hanoi
Objetivo:
Transferir toda a torre para uma das outras varetas, movendo um disco de
cada vez, mas nunca movendo um disco maior sobre um menor
Solues particulares:
Seja T(n) o nmero mnimo de movimentos para transferir n discos de
uma vareta para outra de acordo com as regras denidas no enunciado do
problema.
No difcil observar que:
T(0) = 0 [nenhum movimento necessrio]
T(1) = 1 [apenas um movimento]
T(2) = 3 [trs movimentos usando as duas varetas]
Torre de Hanoi
Generalizao da soluo:
Para trs discos, a soluo correta transferir os dois discos do topo para a
vareta do meio, transferir o terceiro disco para a outra vareta e, nalmente,
mover os outros dois discos sobre o topo do terceiro.
Para n discos:
1. Transfere-se os n 1 discos menores para outra vareta (por exemplo, a
do meio), requerendo T(n 1) movimentos.
2. Transfere-se o disco maior para a outra vareta (1 movimento).
3. Transfere-se os n 1 discos menores para o topo do disco maior,
requerendo-se T(n 1) movimentos novamente.
Torre de Hanoi
Equao de recorrncia para este problema pode ser expressa por:
T(0) = 0
T(n) = 2T(n 1) +1, para n > 0
Torre de Hanoi
Para pequenos valores de n temos:
n 0 1 2 3 4 5 6
T(n) 0 1 3 7 15 31 63
Esta recorrncia pode ser expressa por
T(n) = 2
n
1
Torre de Hanoi
Provando por induo matemtica temos:
Caso base. Para n = 0 temos que T(0) = 2
0
1 = 0, que o valor presente
na equao de recorrncia.
Induo. A induo ser feita em n. Vamos supor que a forma fechada seja
vlida para todos os valores at n 1, ou seja, T(n 1) = 2
n1
1.
Vamos provar que esta forma fechada de fato vlida para T(n).
T(n) = 2T(n 1) +1 = 2(2
n1
1) +1 = 2
n
2 +1 = 2
n
1.
.
.
. A forma fechada proposta tambm vlida para n.
Estratgia para resoluo da equao
A recorrncia da Torre de Hanoi aparece em vrias aplicaes de todos os tipos.
Normalmente, existem trs etapas para achar uma forma fechada para o valor
de T(n):
1. Analisar pequenos casos. Com isto podemos ter um entendimento melhor
do problema e, ao mesmo tempo, ajudar nos dois passos seguintes.
2. Achar e provar uma recorrncia para o valor de T(n).
3. Achar e provar uma forma fechada para a recorrncia.
Linhas no plano
Problema:
Qual o nmero mximo de regies L
n
determinado por n retas no plano?
Lembre-se que um plano sem nenhuma reta tem uma regio, com uma reta
tem duas regies e com duas retas tm quatro regies.
Anlise Amortizada
Introduo
Cenrio:
Manter uma estrutura de dados sobre uma seqncia de n operaes.
Custo por operao:
Pode ser alto, por exemplo, (n).
Custo total:
Pode no ser n custo no pior caso de uma operao.
Questo:
Como fazer uma anlise mais precisa num cenrio como esse?
Soluo:
Anlise amortizada.
Custo amortizado
Denio:
Custo mdio de uma operao sobre uma seqncia de n operaes, max-
imizado sobre todos n e todas seqncias.
Observaes importantes:
O custo amortizado no a mesma coisa que a anlise do caso mdio.
No feita nenhuma suposio sobre a seqncia de entrada.
Amortizao ainda um princpio de pior caso.
Tcnicas de anlise amortizada
Trs tcnicas que podem ser usadas para analisar tais cenrios so:
Mtodo Agregado (Aggregate Method).
Mtodo Contbil (Accounting Method).
Mtodo Potencial (Potential Method).
Referncia:
Introduction to Algorithms, 2nd edition. Thomas H. Cormen, Charles E. Leis-
erson, Ronald L. Rivest, Clifford Stein. MIT Press, Hardcover, Published July
2001, ISBN 0070131511.
Exemplo: Incrementar um contador binrio
Exemplo didtico (toy example).
Estrutura de dados:
Arranjo de k bits, usado para armazenar/contar nmeros de 0 a 2
k
1 e
depois novamente a 0.
Operao:
Incrementar.
Custo:
Nmero de bits trocados.
Exemplo: arranjo de 5 bits.
Exemplo: Incrementar um contador binrio
Bits Custo
00000
00001 1
00010 2
00011 1
00100 3
Custo varia!
Custo mximo: O(logn).
Contador binrio: Cdigo
Contador binrio de k bits.
Vetor A[0. . . k 1]
Bit menos signicativo na posio A[0].
Bit mais signicativo na posio A[k 1].
Um nmero binrio x dado por
k1
i=0
A[i] 2
i
.
length[A] = k.
Para somar 1 (mdulo 2
k
) ao valor do contador, pode-se usar o procedimento
Increment(A).
Contador binrio: Cdigo
Increment(A)
i 0
while (i < length[A]) (A[i] = 1) do
begin
A[i] 0
i i + 1
end
if i < length[A]
then A[i] 1
EndIncrement
Essencialmente o mesmo algoritmo implementado pelo contador Ripple-
Carry em hardware.
Mtodo agregado
Idia:
Conte o custo total para as n operaes.
Tcnica de contagem:
Ad hoc, ou seja, cada caso um caso.
Contador binrio
Custo por linha varia.
Difcil de somar.
Soluo:
Conte por coluna, ou seja, quantas vezes o i-simo bit trocado.
Some os custos.
Exemplo: arranjo de 5 bits (k = 5).
Contador binrio
Bits Custo
0 0 0 0 0
0 0 0 0 1 1
0 0 0 1 0 2
0 0 0 1 1 1
0 0 1 0 0 3
.
.
.
1 1 1 1 1 1
0 0 0 0 0 5

2 4 8 16 32
Contador binrio
Custo:
Para uma seqncia de n incrementos (2
k
), temos:
Bit de ordem
2
4
2
3
2
2
2
1
2
0
2 4 8 16 32
ou seja, o bit de ordem 2
i
trocado 2
ki
vezes. Logo, o custo total de
trocas
k
i=1
2
i
= 2
k+1
2 = 2 2
k
2 = 2n 2 = O(n)
Custo amortizado por troca = O(n)/n = O(1).
Mtodo contbil
Estrutura de dados vem com uma conta bancria.
cada operao alocado um custo xo (custo amortizado).
Custos devem ser escolhidos cuidadosamente.
Se o custo real menor que o custo alocado, deposite a diferena na conta
bancria.
Se o custo real maior que o custo alocado, retire a diferena da conta
bancria para pagar pela operao.
Prove que o saldo nunca ca negativo.
Mtodo contbil
Qual o signicado do saldo car negativo?
Para a seqncia de operaes at aquele momento, o custo amortizado
total no representa um limite superior para o custo real total.
Concluso:
Seqncia de n operaes custa no mximo n custo amortizado.
Contador binrio
Custo amortizado para trocar 0 1 = 2 crditos.
Pague 1 crdito pela operao e deposite 1 crdito na conta.
Custo amortizado para trocar 1 0 = 0 crditos
Retire da conta 1 crdito para pagar pela operao.
Invariante:
Cada bit 1 no contador gerou um crdito.
Logo, sempre existe crdito para pagar pela operao de trocar 1 0.
Anlise amortizada
Custo para resetar os bits no while pago pelos crditos dos bits que foram
setados.
No mximo um bit setado.
Custo da operao de incremento no mximo 2.
O nmero de bits 1 no contador nunca negativo.
Saldo nunca negativo.
Para n operaes de incremento, o custo amortizado total O(n), que um
limite para o custo real total.
Mtodo potencial
Associa-se uma energia potencial a cada estrutura de dados.
Energia potencial o potencial para fazer um estrago.
Custo amortizado = Custo atual +
Novo potencial
Potencial anterior
Deve-se pagar para incrementar o potencial da estrutura de dados.
Se a operao tem um custo cumulativo alto mas reduz bastante o potencial,
ento o custo amortizado baixo.
Como encontrar o potencial?
Determine o que torna uma estrutura de dados ruim.
Regras bsicas para funes potenciais
Devem ser sempre no negativas.
Devem comear de zero.
Implica uma seqncia de n operaes que custam no mximo n custo
amortizado.
Contador binrio
Estrutura de dados ruim se tem vrios 1s.
Seja (Contador)= # 1s no contador.
Potencial aumenta quando h um incremento:
= # (0 1) # (1 0)
= 1 # (1 0)
Custo amortizado do incremento:
= Custo real (atual) + Aumento do potencial
= (1 + # (1 0) + (1 # (1 0)
= 2
Custo amortizado 2 e o custo de n incrementos no mximo 2n.
A linguagem de programao Pascal
Os programas apresentados no livro-texto usam apenas as caractersticas
bsicas do Pascal.
So evitadas facilidades mais avanadas disponveis em alguns compi-
ladores.
No so apresentadas a linguagem na sua totalidade, apenas examinamos
algumas caractersticas.
Um programa Pascal dividido nas seguinte partes:
program {Cabealho do programa}
label {Declarao de rtulo para goto}
const {Definio de constantes}
type {Definio de tipos de dados}
var {Declarao de variveis}
procedure ou function {Declarao de subprogramas}
begin {Incio do corpo principal do programa}
.
.
. {Comandos do programa}
end {Fim do corpo principal do programa}
Tipos em Pascal
Regra geral:
Deve-se tornar explcito o tipo associado quando se declara uma constante,
varivel ou funo.
Isso permite testes de consistncia durante o tempo de compilao.
A denio de tipos permite ao programador alterar o nome de tipos exis-
tentes e criar um nmero ilimitado de outros tipos.
No caso do Pascal, os tipos podem ser:
simples,
estruturados e
apontadores.
Tipos simples
So grupos de valores indivisveis (integer, boolean, char e real).
Tipos simples adicionais podem ser enumerados por meio de:
Listagem de novos grupos de valores como, por exemplo:
type cor = (vermelho, azul, rosa);
.
.
.
var c : cor;
.
.
.
c := rosa;
Indicao de subintervalos como, por exemplo:
type ano = 1900..1999;
type letra = A..Z;
.
.
.
var a : ano;
var b : letra;
As atribuies a:=1986 e b:=B so possveis, mas a:=2001 e b:=7 no o
so.
Tipos estruturados
Denem uma coleo de valores simples, ou um agregado de valores de tipos
diferentes.
Existem quatro tipos estruturados primitivos:
Arranjos: tabela n-dimensional de valores homogneos de qualquer tipo.
Indexada por um ou mais tipos simples, exceto o tipo real.
Registros: unio de valores de tipos quaisquer, cujos campos podem ser
acessados pelos seus nomes.
Conjuntos: coleo de todos os subconjuntos de algum tipo simples, com
operadores especiais (interseco), + (unio), (diferena) e in (per-
tence a) denidos para todos os tipos conjuntos.
Arquivos: seqncia de valores homogneos de qualquer tipo. Geral-
mente associado com alguma unidade externa.
Tipo estruturado arranjo: Exemplo
type cartao = array [1..80] of char;
type matriz = array [1..5, 1..5] of real;
type coluna = array [1..3] of real;
type linha = array [ano] of char;
type alfa = packed array [1..n] of char;
type vetor = array [1..n] of integer;
A constante n deve ser previamente declarada
const n = 20;
Dada a varivel
var x: coluna;
as atribuies x[1]:=0.75, x[2]:=0.85 e x[3]:=1.5 so possveis.
Tipo estruturado registro: Exemplo
type data = record
dia : 1..31;
mes : 1..12;
end;
type pessoa = record
sobrenome : alfa;
primeironome : alfa;
aniversrio : data;
sexo : (m, f);
end;
Declarada a varivel
var p: pessoa;
valores particulares podem ser atribudos:
p.sobrenome := Ziviani;
p.primeironome := Patricia;
p.aniversrio.dia := 21;
p.aniversrio.ms := 10;
p.sexo := f;
Tipo estruturado conjunto: Exemplo
type conjint = set of 1..9;
type conjcor = set of cor;
type conjchar = set of char;
O tipo cor deve ser previamente denido como
type cor = (vermelho, azul, rosa);
Declaradas as variveis
var ci : conjint;
var cc : array [1..5] of conjcor;
var ch : conjchar;
Valores particulares podem ser construdos e atribudos:
ci := [1,4,9];
cc[2] := [vermelho..rosa];
cc[4] := [ ];
cc[5] := [azul, rosa];
Tipo estruturado conjunto: Exemplo
Prioridade: interseo precede unio e diferena, que precedem pertence
a.
Exemplos:
[1..5,7]
*
[4,6,8] [4]
[1..3,5] + [4,6] [1..6]
[1..3,5] - [2,4] [1,3,5]
2 in [1..5] verdadeiro
Tipo estruturado arquivo: Exemplo
type arquivopessoal = file of Pessoa;
O programa abaixo copia o contedo do arquivo Velho no arquivo Novo.
(Atribuio de nomes de arquivos externos ao programa varia de compilador
para compilador.)
program Copia (Velho, Novo); {Copia o arquivo Velho no arquivo Novo}
type Pessoa = record
Sobrenome : alfa; PrimeiroNome: alfa;
Aniversario : data; Sexo : (m, f);
end;
var Velho, Novo : file of Pessoa;
Registro : Pessoa;
begin
reset(Velho); rewrite(Novo);
while not eof(Velho) do
begin
read(Velho, Registro); write(Novo, Registro);
end;
end.
Tipo apontador
So teis para criar estruturas de dados encadeadas, do tipo listas, rvores
e grafos.
Um apontador uma varivel que referencia outra varivel alocada dinami-
camente.
Em geral, a varivel referenciada denida como um registro com um apon-
tador para outro elemento do mesmo tipo.
type Apontador = ^No;
type No = record
Chave: integer
Apont: Apontador;
end;
Dada uma varivel
var Lista: Apontador;
possvel criar uma lista como a ilustrada.
Lista 200 100 50 nil
...
Separador de comandos
O ponto e vrgula atua como um separador de comandos.
Quando mal colocado, pode causar erros que no so detectados em tempo
de compilao.
Exemplo: o trecho de programa abaixo est sintaticamente correto. Entre-
tanto, o comando de adio ser executado sempre, e no somente quando
o valor da varivel a for igual a zero.
if a = 0 then;
a := a + 1;
Passagem de parmetros
Por valor ou por varivel (ou referncia).
A passagem de parmetro por varivel deve ser utilizada se o valor pode
sofrer alterao dentro do procedimento, e o novo valor deve retornar para
quem chamou o procedimento.
Exemplo: SomaUm recebe o parmetro x por valor e o parmetro y por vari-
vel.
program Teste;
var a, b: integer;
procedure SomaUm (x: integer; var y: integer);
begin
x := x + 1; y := y + 1;
writeln(Procedimento SomaUm:, x, y);
end;
begin {Programa principal}
a := 0; b := 0; SomaUm(a,b);
writeln(Programa principal:, a, b);
end.
Resultado da execuo:
Procedimento SomaUm: 1 1
Programa principal: 0 1

Pa2e Cap1

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Pa2e Cap1

Enviado por

Direitos autorais:

Formatos disponíveis

Algoritmos e

cn. Assim, c n para qualquer n n

UFMG/ICEx/DCC Algoritmos e Estruturas de Dados II 80

UFMG/ICEx/DCC Algoritmos e Estruturas de Dados II 93

, para alguma constante > 0.

para toda constante positiva . Conseqentemente, a recorrncia cai na

Você também pode gostar