19.1 - Exercicios Resolvidos - LKT e LKC

Termos de referência do Trabalho individual
Métodos de ordenação, métodos de pesquisa e Análise de complexidade de algoritmos

Prazo: 1ª aula da semana de 27 a 31 de Agosto
Trabalho com capítulos 1, 2, 3, sem capa, sem índice; impresso, agrafado
Apresentação em grupo
Capitulo 1 - Ordenação
 Estude todos os métodos de ordenação
 Aprofunde o método que lhe foi indicado na sala; aprofunde mais um a sua escolha
 Aplique/teste (escreva um programa simples para ler, ordenar e imprimir dados)
 Avaliar a complexidade do método
Capitulo 2 - pesquisa
 Estude todos os métodos de pesquisa
 Aplique/teste (escreva um programa simples para ler, pesquisar e imprimir dados)
 Avaliar a complexidade do método
Capitulo 3 – complexidade de algoritmos
 Resolva os exercícios 1 e escreva uma único parágrafo-resumo (ate 5 linhas) sobre a complexidade de
algoritmos
 Resolva o exercício 3 com base no 2
1. Leia atentamente a ficha Aula11 – ComplexidadeAlgoritimica de Rossana & Hamilton, 2007 e
responda:
a) O que é análise de algoritmos e porquê o fazemos
b) Como podemos avaliar algoritmos
c) Quais são os três aspectos de complexidade. Dê exemplo.
d) Quais os tipos de avaliação de algoritmos
e) Quais as notações
f) O que é a complexidade de tempo. Dê exemplos de complexidade assimptótica
g) Quais são as principais classes de complexidade
h) Quais são as regras para análise de algoritmos
2. Exercícios resolvidos. Calcule a complexidade e ordem de crescimento
a) int x, y, z, p, k;
x=0; y=3;
p=x+y;
k=p+x;
boolean q=(p<k);
System.Out.print(“Digite um número”+k+p);
Resolução:
i. avaliemos a complexidade de cada instrução
Instrução Regra Complexidade
int x, y, z, p, k; R1 O(1)
x=0; y=3; R1 O(1)
p=x+y; R1 O(1)
k=p+x; R1 O(1)
boolean q=(p<k); R1 O(1)
System.Out.print(“Digite um número”+k+p); R1 O(1)
ii. o tempo t(n) de execução do algoritmo acima não é superior á soma do tempo de execução de cada instrução
ou seja:
t(n)<O(1)+ O(1)+ O(1)+ O(1)+ O(1)+ O(1)
iii. Com base nas propriedades apresentadas na página 6 e outras definições, resolvamos a inequação
t(n)<O(1)+ O(1)+ O(1)+ O(1)+ O(1)+ O(1) Agrupando duas parcelas
t(n)<O(max(1,1))+ O(max(1,1))+ O(max(1,1)) 4ª propriedade, pag6
t(n)<O(1)+O(1)+O(1) 4ª propriedade, pag6
t(n)<O(1) Tabela da pag 8
iv. Conclusão: De acordo com a tabela da pag. 8, o algoritmo tem ordem de complexidade constante
b) int i;
for(i=1; i<n; i++){
a[i] = 0;}
Resolução:
Instrução Regra Complexidade
int i; R1 O(1)
for(i=1; i<n; i++){ R3. Qtas vezes Portanto a complexidade
o ciclo é é O(n-1)
executado –
(n-1)vezes
a[i] = 0;} R1 O(1)
ii. o tempo t(n) de execução do algoritmo acima não é superior á soma do tempo de execução de cada instrução
ou seja:
t(n)<O(1)+ O(n-1)* O(1)
iii. Com base nas propriedades apresentadas na página 6 e outras definições, resolvamos a inequação
t(n)<O(1)+ O(n-1)* O(1) 5ª propriedade, pag6
t(n)<O(1)+ O((n-1)* 1) 4ª propriedade, pag6
t(n)<O(max(O(1),O(n-1))
t(n)<O(n-1)
t(n)<O(n-1) Da algebra
 t(n)<O(n)+O(-1) 4ª propriedade, pag6
 t(n)<O(max(n, -1))
 t(n)<O(n) Tabela da pag 8
iv. Conclusão: De acordo com a tabela da pag. 8, o algoritmo tem ordem de complexidade linear
c) if (s>t){
int x, y, z, p, k;
x=0; y=3;
p=x+y;
k=p+x;
boolean q=(p<k);
System.Out.print(“Digite um número”+k+p);
}else{
int i;
for(i=1; i<n; i++){
a[i] = 0;}
}
Resolução:
ver avaliação feita na alínea 2a) e 2b)
ii. o tempo t(n) de execução do algoritmo acima não é superior á soma do tempo de execução de cada instrução,
ou seja (e de acordo com a regra 5):
t(n)<O(<condição>)+ O(max(O(<ParteVerdadeira>),O(<ParteFalsa>))
t(n)<O(1)+O(max(O(O(1)+ O(1)+ O(1)+ O(1)+ O(1)+ O(1)), O(O(1)+ O(n-1)* O(1)))
de acordo com a resolução de 2a) e 2b) temos
t(n)<O(1)+O(max(1, (n))=O(1)+O(n); aplicando a 4ª propriedade da pag6 tem-se
t(n)<O(n) pelo que o algoritmo tem ordem de complexidade linear
3. Exercícios não resolvidos. Calcule a complexidade e ordem de crescimento
a) int resultado = a[0];
int i = 1;
while (i < n)
resultado = resultado
+ a[i];
b) public void bubbleSort(){

for(inti=n-1; i>0; i--)
for(int j=0; j<i; j++)
if(a[j]>a[j+1]){
double aux=a[j];
a[j]=a[j+1];
a[j+1]=aux;
}
c) int i, j, k, count = 0;
for (i = 0; i < n; i++)
for (j = 0; j < n;
j++)
for (k = 0; k < n;
k++)
count++;
d) for (int i = 1; i < n;

i++){
min = i;
for (int j = i; j< n;
j++){
if (a[j] <
a[min]){
min = j;
x = a[min];
a[min] = a[i];
a[i] = x;
}
}
}
e) int x = 0, n, j = n;
while ( j >0 ){
for (int j = 1; j <= i;
j++){
x += 1;
}
j += j / 2;
}

19.1 - Exercicios Resolvidos - LKT e LKC

Enviado por

Direitos autorais:

Formatos disponíveis

19.1 - Exercicios Resolvidos - LKT e LKC

Enviado por

Dados do documento

Descrição 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

19.1 - Exercicios Resolvidos - LKT e LKC

Enviado por

Direitos autorais:

Formatos disponíveis

Termos de referência do Trabalho individual

Métodos de ordenação, métodos de pesquisa e Análise de complexidade de algoritmos

b) public void bubbleSort(){

d) for (int i = 1; i < n;

Você também pode gostar