Métodos Pesquisa Algoritmos

Algoritmos Iterativos: Análise
Métodos de Pesquisa – Análise das Operações Primitivas
• Há uma grande variedade de métodos de pesquisa;

• A escolha de um método de pesquisa para uma aplicação
depende principalmente:
– Da quantidade de dados envolvidos;
– De o arquivo (conjunto) estar sujeito a inserções e retiradas
frequentes; ou
– Do conteúdo do arquivo ser praticamente estável.
• Além disso, é importante considerar os algoritmos de
pesquisa como sendo operações associadas a tipos
abstratos de dados, de tal forma que haja independência de
implementação.
• Apesar da existência de várias estruturas de dados e muitos
algoritmos de pesquisa, vamos analisar: o método de
Pesquisa sequencial e o método de Pesquisa binária.
Métodos de Pesquisa Sequencial – Análise das Operações Primitivas
• O método de pesquisa sequencial é o método de pesquisa

mais simples que existe e funciona da seguinte forma:
– A partir do primeiro elemento do conjunto;
– Pesquise sequencialmente até encontrar a chave procurada;
– Então pare retornando a posição onde se encontra o elemento ou -1.
Vamos analisar o algoritmo no pior caso considerando as operações

primitivas? Qual a configuração da entrada para o pior caso?
Algoritmo pesquisaSequencial( A, n, chave )

Entrada: um vetor A com n 1 elementos.
Saída: posição do elemento ou -1 não achou
para (i = 0; i  n-1; i++) faça
se (A[i] = chave)
return i;
return -1;
Fim- Algoritmo

para (i = 0; i  n-1; i++) faça

se (A[i] = chave)
return i;
return -1;
Fim- Algoritmo
• O método de pesquisa sequencial é o método de pesquisa

mais simples que existe e funciona da seguinte forma:
– A partir do primeiro elemento do conjunto;
– Pesquise sequencialmente até encontrar a chave procurada;
– Então pare retornando a posição onde se encontra o elemento ou -1.

primitivas? Qual a configuração da entrada para o pior caso?

para (i = 0; i  n-1; i++) faça
T(n) = 1 + i =0 + i =0 3 +
n n −1
2
se (A[i] = chave)
return i; 1 = 1 + 2(n +1) + 3n + 1 =
T(n) = 5n + 4 op. primitivas
return -1;
Fim- Algoritmo
Métodos de Pesquisa Binária – Análise das Operações Primitivas
• O método de pesquisa binária é um método de pesquisa

utilizado para conjuntos ordenados e funciona da seguinte
forma:
– Para saber se uma chave está no conjunto compare com o elemento do meio;
– Se Achou retorna a posição encontrada;
– Se a chave é menor então procure na primeira metade;
– Se a chave é maior procura na segunda metade;
– Caso não tenha encontrado o elemento retorna -1;

primitivas?
Em que situação ocorre o pior caso?

Algoritmo pesquisaBinária( A, n, chave )

first = 0; last = n-1;
enquanto (first <= last ) faça
middle = (first + last) div 2;
se (chave = A[middle]) então
return middle;
se (chave < A[middle]) então
last = middle-1;
senão
first = middle + 1;
fim-enquanto
return -1;
Fim- Algoritmo
Algoritmo pesquisaBinária( A, n, chave )

first = 0; last = n-1; 3+
enquanto (first <= last ) faça
meio = (first + last) div 2; +
se (chave = A[middle])
então return middle;
+
se (chave < A[middle])
então last = middle-1;
senão first = middle + 1;
fim-enquanto
return -1; 1
Fim- Algoritmo
T(n) = 3 + + + 1 = 10 + 5 op.
Exercício (1/3) - Número de Fibonacci
1. A representação matricial para a sequenca de Fibonacci

obtém o enésimo elemento da sequencia utiliza a técnica
de divisão e conquista (mas sem recursividade). Qual sua
complexidade? enquanto( i > 0) faça
início
Módulo fib(n) se i % 2 = 0 então
início
início
a ← db + ca;
se (n <= 0) retorna 0; b ← d(b+a) + cd;
i ← n-1; fim
a ← 1; c ← c 2 + d 2;
b ← 0; d ← d (2c + d));
i ← i div 2;
c ← 0;
fim
d ← 1; retorn a + b
fim
Exercício (2/3) - Métodos de Pesquisa Binária
2. ENADE 2005 – Exercício em Sala

No processo de pesquisa binária em um vetor ordenado, os
números máximos de comparações necessárias para se
determinar se um elemento faz parte de vetores com tamanhos
50, 1.000 e 300 são, respectivamente, iguais a
A) 5, 100 e 30.
B) 6, 10 e 9.
C) 8, 31 e 18.
D) 10, 100 e 30.
E) 25, 500 e 150.
Exercício (3/3)
4. Realize a análise, no pior caso, em termos das

operações primitivas:
Algoritmo: procuraKEsimoDoConjunto(A, n, k)
Entrada: um vetor A com n 1 elementos não ordenados. K-ésimo elemento
(em ordem) a ser procurado dentro do vetor.
Início
para (i ← 0; i < k; i++) faça
mini ← i
para (j ← i+1; j < n; j++) faça
if (A[j] < A[mini]) mini ← j;
tmp ← A[i];
A[i] ← A[mini];
A[mini] ← tmp;
retorne A[k-1]
Fim-Algoritmo
Métodos de Ordenação
• Vamos entender e analisar os métodos de ordenação:
a) Método da bolha (bubbleSort)

b) Método da seleção direta (selectSort)
c) Método da Inserção direta (insertionSort)
• Na avaliação do método “c” serão considerados o tempo

de cada instrução/placa de processamento e será
realizada uma análise no melhor e pior caso;
• Nos outros dois métodos será considerado o tempo como

as operações primitivas básicas descritas anteriormente e
será realizada uma análise somente no pior caso.
Métodos de Ordenação – Análise das Operações Primitivas - Bolha (1/9)
Também conhecido como demônio das trocas, consiste na

comparação de pares de valores de ordenação, trocando os
elementos correspondentes caso estejam fora de ordem.
O nome bolha deve-se ao fato de que, ao se fazer o
acompanhamento ilustrativo do processo da ordenação,
tem-se a impressão de que os valores flutuam até sua
correta posição.
O algoritmo básico do processo de ordenação é:
• Em cada passo, cada elemento é comparado com o
próximo;
• Se o elemento estiver fora de ordem, a troca é realizada;
• Realizam-se tantos passos quantos forem necessários até
que não ocorram mais trocas.
Por exemplo:
Suponha o conjunto desordenado de elementos

inteiros com 7 elementos:
32 7 28 43 92 72 5
0 1 2 3 4 5 6
Passo 1 Passo 2
32 7 28 43 92 72 5 7 28 32 43 72 5 92
0 1 2 3 4 5 6 0 1 2 3 4 5 6
7 32
7 28 32 43
0 1
0 1 2 3
28 32
1 2 5 72
32 43 92 4 5
2 3 4
72 92
4 5
5 92
5 6
Passo 3 Passo 4
7 28 32 43 5 72 92 7 28 32 5 43 72 92
0 1 2 3 4 5 6 0 1 2 3 4 5 6
7 28 32
7 28
0 1 2
0 1
5 43
5 32
3 4
2 3
Passo 5 Passo 6
7 28 5 32 43 72 92 7 5 28 32 43 72 92
0 1 2 3 4 5 6 0 1 2 3 4 5 6
7
5 7
0
0 1
5 28
Resultado Final
1 2
5 7 28 32 43 72 92
0 1 2 3 4 5 6
Observe que o conjunto ficou

ordenado após 6 passos.
Algoritmo BubbleSort ( conjunto, n )

Entrada: - n: número de elementos do conjunto;
- conjunto: vetor com os dados desordenados.
Saída: - conjunto: vetor ordenado.
início
para (i  0; i < n – 1; i++) faça
para (j  0; j < n – i-1; j++) faça
Se ( conjunto [j] > conjunto [j+1] ) então
// permuta conjunto [j] com conjunto [j+1]
aux  conjunto [j];
conjunto [j]  conjunto [j+1];
conjunto [j+1]  aux;
fim.
Qual configuração do vetor ocorre o melhor e o pior caso no

tempo de análise do algoritmo?
• Realizando a análise do bloco interno (pior caso):
 
n −1 n−2
para(i0; i<n–1; i++) faça 1 + i =0
2 + i =0
1
 
n−2 n −i −1
i=01 +  
n−2 n−2 n −i − 2
para(j0; j<n–i-1; j++) faça i =0 j =0
3 +
i =0 j =0
1
Se (conjunto[j]>conjunto[j+1]) então
//permuta conjunto[j] com conjunto[j+1]
aux  conjunto [j];
 
n−2 n −i − 2
i =0 j =0
13
conjunto [j]  conjunto [j+1];
conjunto [j+1]  aux;
fim.
17 3
Total de Operações Primitivas: T(n) = n2 − n − 4
(vetor em ordem decrescente - pior caso)2 2
Observação: Desenvolvimento na próxima transparência.
 
n−2 n −i − 2
t(n) = 1 + i =0 2 + i=01 + i=01 +   3 + i =0  j =0 1+
n −1 n−2 n−2 n−2 n −i −1 n−2 n −i − 2
i =0 j =0 i =0 j =0
13
 
n−2 n −i − 2
 
n−2 n −i −1
t(n) = 1 + 2n + 2(n-1) + i =0 j =0
3 + i =0 j =0
14
 
n−2 n −i − 2
 
n−2
i =0
n −i −1
j =0
3 + i =0 j =0
14 = 3n−2(n − i) + 14n−2(n − i − 1) =
i =0 i =0
3 n - 3 i + 14 
n−2
 
n−2 n−2 n−2 n−2
i =0 i =0
n - 14 i =0
i - 14 i =0
1 =
i =0
17ni =01 - 17i =0 i - 14(n-1) = 17n(n-1) – 17i =1 (i − 1) - 14(n-1) =

n−2 n−2 n −1
– 17n + 14n + 14 - 17i =1 i + 17i =11=

n −1 n −1
17n2
17 17
17n2 – 17n - 14n + 17(n-1) – (n-1)n = 17n2 – 31n + 14 + 17(n-1) - (n-1)n =
2 2
17 17 2 11
- n + 2 = 2 n − 2 n−3
17 2
17n2 – 31n + 14 + 17n -17 n
2
17 2 17 17 2 3
t(n) = 1 + 2n +2 -2 + 2n - n- 3= n − n−4
2 2 2
• Verificação: É possível verificar se a função, t(n), encontrada

está correta, basta para isto, realizar a contagem das
operações primitivas para alguns valores de n e comparar
com o valor obtido pelo dessa função.
• Método da Bolha
– Contagem das operações primitivas
• Se n =1, tem-se 3 operações primitivas;
• Se n = 2, são 27 operações primitivas.
– Cálculo para t(n)
17 3
• Se n = 1, t(1) = 2
(1) 2 − (1) − 4
2 = 3 operações primitivas;
• Se n = 2, t(2) = 172 (2) 2
−
3
2
(2) − 4 = 27 operações primitivas.
– Pode-se observar então que a função t(n) encontrada
está correta.
Métodos de Ordenação – Análise das Operações Primitivas - Seleção (1/9)
O processo de ordenação consiste em uma seleção sucessiva

do maior (ou menor) valor contido no vetor. Este processo é
repetido para o segmento que contém os elementos ainda
não selecionados.
Pode-se então definir um algoritmo de seleção direta, como:
• A cada etapa realizada, é identificado o menor ou o maior
elemento dentro do segmento que contém os elementos
ainda não selecionados;
• É realizada uma troca do elemento identificado na etapa
anterior, com o primeiro elemento do segmento;
• O tamanho do segmento é atualizado;
• Este processo é interrompido no momento em que o
segmento ficar com apenas um elemento.
Por exemplo:

32 7 28 43 92 72 5
0 1 2 3 4 5 6
32 7 28 43 92 72 5 Tamanho do segmento = 7
Posição de
troca 0 1 2 3 4 5 6
Passo 1 32 7 28 43 5 72 92 Tamanho do segmento = 6

0 1 2 3 4 5 6

0 1 2 3 4 5 6

0 1 2 3 4 5 6

0 1 2 3 4 5 6

0 1 2 3 4 5 6

0 1 2 3 4 5 6
Observe que o conjunto foi ordenado após 6 passos.

Algoritmo SelectSort (conjunto, n )

- conjunto: vetor com os dados desordenado.
Qual
início
inteiro i, indConjunto, j, maior;
configuração do
para (i  n-1; i > 0; i--) faça vetor ocorre o
maior  conjunto[0]; melhor e o pior
indConjunto = 0; caso no tempo de
para (j  1; j <= i; j++) faça análise do
se ( conjunto[j] > maior) então algoritmo?
maior  conjunto[j];
indConjunto  j;
conjunto[ indConjunto ]  conjunto [ i ];
conjunto[ i ]  maior;
fim.
Algoritmo SelectSort (conjunto, n )

- conjunto: vetor com os dados desordenado.
início
inteiro i, indConjunto, j, valor;
para (i  n-1; i > 0; i--) faça
maior  conjunto[0];
indConjunto = 0;
para (j  1; j <= i; j++) faça
se ( conjunto[j] > maior) então
indConjunto  j;
conjunto[ i ]  maior;fim.
• Realizando a análise do bloco interno (pior caso):
2 + i =01 + 10i =11

n −1 n −1
para (i  n-1; i > 0; i--) faça
maior  conjunto[0];
indConjunto  0;
i=1  j =11+ 6i=1  j =11
n −1 i +1 n −1 i
para (j  1; j <= i; j++) faça
se ( conjunto[j] > maior) então
indConjunto  j;
conjunto[ i ]  maior;
7 2 17
Total de Operações Primitivas: T(n) = n + n−9
2 2
• Observação:
– Veja que o bloco interno que envolve a repetição da variável i tem os índices
superior e inferior da somatória alterados. Isto acontece pois j depende de i no
bloco mais interno e se não for realizada esta modificação a contagem e o
valor do contador i e j não se correspondem e isto é essencial para o
resultado da contagem. No método da bolha isto não era um problema pois a
repetição mais interna não dependia de i, o que ocorre no método da seleção.
– Exemplo: Suponha n = 3 e a operação de comparação j <= i:
 
n−2 i +1
• a) 1 se i = 0 → j = 1
i =0 j =1
• se i = 1 → j varia de 1 até 2
• Total = 3 operações primitivas;
 
n −1 i +1
• b) 1 se i = 1 → j varia de 1 até 2
i =1 j =1
• se i = 2 → j varia de 1 até 3 Observa-se que i varia
de 1 até 2, assim, a operação
• Total = 5 operações primitivas; j <= i será executada 2
• No código: para (i  2; i > 0; i--) vezes quando i = 1 e 3 vezes
quando i = 2 totalizando 5
• para (j  1; j <= i; j++) operações primitivas conforme
O item b.
 
n −1
t(n) = 2 + i =01 + 10i =11 + i =1  j =11 + 6
n −1 n −1 n −1 i +1 i
i =1 j =1
1
+ 10(n-1) + i =1 (i + 1) + 6i =1 i
n −1 n −1
t(n) = 2 + n

n −1
i=11 + 6i=1 i
n −1 n −1
t(n) = 2 + n + 10(n-1) + i =1
i +
+ 10n -10 + 7i =1 i + 

n −1 n −1
t(n) = 2 + n 1
i =1
t(n) = 2 + n + 10n -10 + 7 (n − 1)n + (n – 1)

2
7 2
t(n) = n + 12n - 7 n - 9
2 2
17
t(n) = 7 n 2 + n - 9
2 2
• Método da Seleção Direta

– Contagem das operações primitivas
• Se n =1, tem-se 3 operações primitivas;
• Se n = 2, são 22 operações primitivas.
– Cálculo para t(n)
7 17
• Se n = 1, t(1) = 2 (1) 2
+
2
(1) − 9 = 3 operações primitivas;
• Se n = 2, t(2) = 72 (2) 2
+
17
2
(2) − 9 = 22 operações primitivas.
– Pode-se observar então que a função t(n) encontrada
está correta.
Métodos de Ordenação – Inserção Direta – Funcionamento (1/5)
Suponha um conjunto de elementos dividido em dois

segmentos: um ordenado e outro desordenado. Inicialmente
o segmento ordenado possui somente o primeiro elemento
do conjunto ( conjunto[1] ) e o segundo segmento o restante
( conjunto[2] até conjunto[TAMMAX]).
Pode-se então definir um algoritmo da inserção direta, como:

• Um primeiro elemento está no vetor ordenado e os demais
no vetor desordenado;
• Retira-se o primeiro elemento do vetor desordenado. Ao
coloca-lo no vetor ordenado, é realizada a devida
comparação para inseri-lo na sua posição correta;
• Repete-se o processo até que todos os elementos tenham
passado para o vetor ordenado
Por exemplo:

32 7 28 43 92 72 5
0 1 2 3 4 5 6
iniciando do final do conjunto

32 7 28 43 92 12 5 ordenado para o começo e
vai decrementando
0 1 2 3 4 5 6 A[i] > Chave = 7
Segmento ordenado Segmento desordenado
Passo 1
7 32 28 43 92 12 5 A[i] > Chave = 28
0 1 2 3 4 5 6
Passo 2 Observe que 43 já

7 28 32 43 92 12 5 está na posição correta
Chave = 43 de inserção
0 1 2 3 4 5 6
Passo 3 Observe que 92 também

7 28 32 43 92 12 5 já está na posição correta
Chave = 92 de inserção
0 1 2 3 4 5 6
Passo 4
7 28 32 43 92 12 5 Chave = 12
0 1 2 3 4 5 6
Passo 5
7 12 28 32 43 92 5 Chave = 5
0 1 2 3 4 5 6
Passo 6
5 7 12 28 32 43 92
0 1 2 3 4 5 6
Observe que o conjunto ficou ordenado após 6 passos.
Discussão:
Este é um método simples, normalmente utilizado para um conjunto
pequeno de dados. Isso ocorre porque este método apresenta uma
baixa eficiência em relação ao tempo total para realizar uma
ordenação. Vamos calcular este tempo?
Métodos de Ordenação – Inserção Direta – Análise do Tempo (1/6)
• Vamos avaliar este método considerando o tempo de cada instrução
(custo) e realizar uma análise no melhor e pior caso. Quando ocorre o
melhor e o pior caso? (Obtido da Referência Básica 1)
Método InsertionSort (A, tamanho = n)

// A = vetor de 0 a n – 1, n >=1
para j  1 até n-1 faça
chave  A[j];
i  j – 1;
// Insere A[j] na seq. Ord. A[0..j-1]
enquanto i >= 0 e A[i] > chave faça
A[i+1]  A[i];
i  i - 1;
A[i+1]  chave;
• Vamos avaliar este método considerando o tempo de cada instrução
(custo) e realizar uma análise no melhor e pior caso. Quando ocorre o
melhor e o pior caso? (Obtido da Referência Básica 1)
• Seja tj o número de vezes que a linha c4 é executada.
Método InsertionSort (A, tamanho = n) Custo Vezes

// A = vetor de 0 a n – 1, n >=1
para j  1 até n-1 faça c1 n
chave  A[j]; c2 n-1
i  j – 1; c3 n-1
// Insere A[j] na seq. Ord. A[0..j-1]

n −1
enquanto i >= 0 e A[i] > chave faça c4 j =1
tj

n −1
A[i+1]  A[i]; c5 j =1
tj − 1
i  i - 1; c6

n −1
tj − 1
j =1
A[i+1]  chave; c7 n-1
• O tempo de execução do algoritmo é a soma dos tempos

de execução de cada instrução executada.
• Para calcular T(n), o tempo de execução de InsertionSort,
somamos os produtos das colunas custo e vezes,
obtendo.
 j =1 tj + c5  j =1 tj − 1
n −1 n −1
T(n) = c1n + c2(n-1) + c3(n-1) +c4
+ c6  j =1 tj − 1 + c7 (n-1)
n −1
• O melhor caso ocorre quando o vetor está ordenado na

ordem correta e o pior caso ocorre se o vetor está
ordenado na ordem inversa.
• No melhor caso a avaliação de A[i]> chave sempre será

falsa logo no primeiro valor i ← j - 1, ou seja, para j = 1, 2,
3, 4,... , n-1 (tj = 1) e o tempo de execução no melhor caso
é
T(n) = c1n + c2 (n-1) + c3(n-1) + c4 (n-1) + c7 (n-1)
T(n) = (c1+ c2 + c3 + c4 + c7) n – (c2 + c3 + c4 + c7).
Esse tempo pode ser expresso como a n + b para constantes a

e b dependendo dos custos de instrução ci, assim, é uma
função linear de n.
• No pior caso devemos comparar cada elemento A[j] com

cada elemento do subarranjo ordenado inteiro, A[1..j-1], e
então tj = j para 1, 2, 3, 4,... , n
Observe que a somatória  j =1 tj pode ser substituída por
n −1
•
n(n + 1) − 1
1
 j =1 i=−11  j =1 ( j + 1) = j =1 j + j =11 = 2 (n − 1)n + (n − 1)
n −1 j −1 n −1 n −1 n −1 1
= = 2
Também observe que a somatória  j =1 (tj − 1) pode ser

n −1
•
substituída por
 j =1 i=01 =  j =1 j =
n −1 j −1 n −1
1
(n − 1)n
2
• Então, o tempo de execução no pior caso é
T(n) = c1 n + c2(n-1) + c3 (n-1) + c4 ( (n+1)n/2 - 1) + c5 (n-

1)n/2 ) + c6 (n-1)n/2 + c7 (n-1)
T(n) = (c4/2 + c5/2 + c6/2) n2 + (c1 + c2 + c3 + c4/2 – c5/2 – c6/2

+ c7) n – (c2 + c3 + c4 + c7).
Esse tempo pode ser expresso como K1 n2 + K2 n + K3 para

constantes K1, K2 e K3 dependendo dos custos de cada
operação/linha ci, assim, é uma função quadrática de n.
Exercício (1/11)
1. Dado o algoritmo abaixo:

Pede-se:
inicio
a) Simular o algoritmo para as
inteiro n, y, z, u, v;
entradas n=6 e y=4.
leia (n);
leia (y); b) O que ele calcula?
z ← 0; c) Calcule o tempo de
u ← n; execução do algoritmo t(n),
v ← y; em termos das operações
enquanto (u  0) faça primitivas, no pior e melhor
se (u % 2 = 1) então caso.
z ← z + v;
u ← u/2; //(idem ao div) Obs.: Considere que o pior caso é
v ← v*2; quando o resto da divisão u % 2 é
sempre 1 e que nesta situação a
escreve( z ); operação z = z + v sempre será
fim executada.
Exercício (2/11)
2. Dado o algoritmo de ordenação para um vetor V de tamanho n calcular o

tempo de execução tinserção(n) no pior caso, considerando todas as seis
operações primitivas, e comparar com o tbolha(n) e tseleção(n). Determinar o
valor n onde um algoritmo torna-se mais rápido que os outros.
Algoritmo ordenaInsDir(V, n)
Entrada: Vetor de inteiros V com tamanho n
Saída: Vetor V ordenado
início
para (inteiro i ← 1; i<n; i++)
inteiro x ← V[i];
inteiro j ← i-1;
enquanto (j >= 0 e V[j] > x)
V[j+1] ← V[j]
j ← j - 1
V[j+1] ← x;
retorne V
fim
Exercício (3/11)
3. Sejam os algoritmos (a) e (b):

Obs.: Considerar que os comandos de repetição “para” nos dois algoritmos
contém 3 instruções no cômputo do custo, por exemplo, seja o primeiro
para do algoritmo “a”: considerar um custo (c1) para a atribuição (i = 0),
um custo (c2) para a comparação (i  n-1) e um custo (c3) para o
incremento.
a)Algoritmo: oQueSou_1(X, n)
Entrada: um vetor X com n 1 elementos.
Saída: ...???
para (i ← 0; i  n-1; i++) faça
a ← 0;
para (j ← 0; j  i; j++) faça
a ← a + X[j]
A[i] ← a/(i+1)
retorne A
Fim-Algoritmo
Exercício (4/11)
b) Algoritmo: oQueSou_2(X, n)
Entrada: um vetor X com n 1 elementos.
Saída: ...???
s←0
para (i ← 0; i  n-1; i++) faça
s ← s + X[i]
A[i] ← s/(i+1)
retorne A
Fim-Algoritmo
Pede-se:
i. O que fazem os dois algoritmos?
ii. Realizar a análise de (a) e (b) por meio do custo (tempo).
iii. Considerando que os custos ci de função encontrada no item “ii” tem o
valor numérico “1”, encontre a fórmula numérica de (a) e (b) e faça o
gráfico comparativo dos dois algoritmos.
iv. A partir de “i”, “ii” e da análise dos dois algoritmos, a que conclusão
podemos chegar?
Exercício (5/11)
4 - POSCOMP – 2004
Exercício (6/11)
5. Sejam os algoritmos abaixo que encontram o valor máximo e o mínimo de

um vetor:
max ← a[0];
a) min ← a[0]; b) max ← a[0];
for(int i ← 1; i<n; i++){ min ← a[0];
if (a[i] > max) max ← a[i]; for (int i ← 1; i<n; i++){
if (a[i] < min) min ← a[i]; if (a[i] > max) max ← a[i];
} else (a[i] < min) min ← a[i];
c) }
if ((n % 2) > 0) {
: a[n] ← a[n-1];
fimDoAnel ← n; I. Encontrar o tempo de execução t(n)
}
else fimDoAnel ← n-1; para os algoritmo 3 algoritmos no pior e
if (a[0] > a[1]) { melhor caso em termos das operações
max ← a[0]; min ← a[1]; primitivas e do custo (tempo).
}else { max ← a[1]; min ← a[0]; }
I. Montar os gráfico de t(n).
for(int i ← 2; (i <= fimDoAnel); i+=2){
if (a[i] > a[i+1]){ II. Encontrar o ponto n onde um
if (a[i] > max) max ← a[i]; Algoritmo torna-se melhor do que o outro.
if (a[i+1] < min) min ← a[i+1];
}else {
if (a[i] < min) min ← a[i];
if (a[i+1] > max) max ← a[i+1];
}
Exercício (7/11)
6. Montar os gráficos para os tempos obtidos com a análise de todas as

operações primitivas e o custo pela placa de processamento para os
problemas:
b.
a.
Algoritmo somaVetorA( a, n) Algoritmo somaSubConjuntosA( a, n)
Entrada: a: vetor de inteiros
Entrada: a: vetor de inteiros
com tamanho n.
com tamanho n. início
Saída: soma de a. i  0;
início enquanto i < n faça
i  0; j  1;
soma  0; soma  a[0];
enquanto j <= i faça
enquanto i < n faça
soma  soma + a[j];
soma  soma + a[i]
j  j + 1;
i  i + 1; escreva(soma);
Retorna soma; i  i + 1;
fim fim
Exercício (8/11)
6. Montar os gráficos para os tempos obtidos com a análise de todas as

operações primitivas e o custo pela placa de processamento para os
problemas:
c. Melhor caso: vetor em ordem crescente;
Pior caso: vetor em ordem decrescente;
Algoritmo determinaTamanhoMaiorSubvetorOrdenadoCrescente( a, n)
Entrada: a: vetor de inteiros com tamanho n.
Saída: c: tamanho do maior subvetor ordenado.
início
para (i 0, c  1; i < n-1; i++) faça
para (i1  i2  k  i; k < n-1 e a[k] < a[k+1];
kk+1,i2i2+1) faça
fim-para
se (c < i2-i1+1)então c  i2-i1+1;
retorna c;
fim
Exercício (9/11)
POSCPOMP 2002
7-
8-
Exercício (10/11)
9. Considere os algoritmos abaixo, as operações primitivas e

as operações de entrada e saída equivalendo a uma
operação primitiva. Fazer os algoritmos e calcular t(n).:
a) Um arranjo A contém n-1 inteiros não repetidos com valores
entre 0 e n-1, ou seja, existe um número desta faixa de
valores que não está em A. Fazer um algoritmo que
encontre este número. A solução é eficiente? Poderia ser
melhor?
b) Suponha que cada linha de uma matriz Anxn consiste de
valores 1 e 0 de tal forma que em cada linha de A todos os
valores 1 vêm antes dos valores 0. Descreva um método
para encontrar a linha que contém o maior número de
valores 1. Seu método é eficiente?
Exercício (11/11)
9. Considere os algoritmos abaixo, as operações primitivas e as operações

de entrada e saída equivalendo a uma operação primitiva. Fazer os
algoritmos e calcular t(n).:
c) Dado um conjunto A = { a1, a2, ..., an } de n inteiros, descreva um

algoritmo para calcular cada uma das somas parciais
k
S k =  ai
i =1
para k = 1, 2, ..., n. (Pressuponha que os vetores são indexados a partir do

0).
Seu algoritmo é eficiente?

Referências Bibliográficas deste material
• CORMEN, T. H. Algoritmos: Teoria e Pratica. Rio de Janeiro:

Campus, 2002 – Capítulo 2 e Capítulo 9.
• GOODRICH, M. T. Projeto de Algoritmos: Fundamentos, Analise e
Exemplos da Internet. Sao Paulo: Bookman, 2004 – Capítulo 1
• PAULO A. S. VELOSO. Complexidade de Algoritmos. 2. ed. Porto
Alegre: Bookman Companhia Ed, 2008 – Capítulo 2.
• ZIVIANI, N. Projeto de Algoritmos Com Implementacoes em Java
e C++. São Paulo: Thomson Pioneira, 2006. – Capítulo 1, Capítulo 4 e
Capítulo 5.

Métodos Pesquisa Algoritmos

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

Métodos Pesquisa Algoritmos

Enviado por

Direitos autorais:

Formatos disponíveis

Algoritmos Iterativos: Análise

Métodos de Pesquisa – Análise das Operações Primitivas

• Há uma grande variedade de métodos de pesquisa;

• O método de pesquisa sequencial é o método de pesquisa

Vamos analisar o algoritmo no pior caso considerando as operações

Algoritmo pesquisaSequencial( A, n, chave )

Algoritmo pesquisaSequencial( A, n, chave )

Entrada: um vetor A com n 1 elementos.

para (i = 0; i  n-1; i++) faça

• O método de pesquisa sequencial é o método de pesquisa

Vamos analisar o algoritmo no pior caso considerando as operações

Algoritmo pesquisaSequencial( A, n, chave )

• O método de pesquisa binária é um método de pesquisa

Vamos analisar o algoritmo no pior caso considerando as operações

Em que situação ocorre o pior caso?

Algoritmo pesquisaBinária( A, n, chave )

Algoritmo pesquisaBinária( A, n, chave )

1. A representação matricial para a sequenca de Fibonacci

2. ENADE 2005 – Exercício em Sala

4. Realize a análise, no pior caso, em termos das

• Vamos entender e analisar os métodos de ordenação:

a) Método da bolha (bubbleSort)

• Na avaliação do método “c” serão considerados o tempo

• Nos outros dois métodos será considerado o tempo como

Também conhecido como demônio das trocas, consiste na

Suponha o conjunto desordenado de elementos

Observe que o conjunto ficou

Algoritmo BubbleSort ( conjunto, n )

Qual configuração do vetor ocorre o melhor e o pior caso no

• Realizando a análise do bloco interno (pior caso):

17ni =01 - 17i =0 i - 14(n-1) = 17n(n-1) – 17i =1 (i − 1) - 14(n-1) =

– 17n + 14n + 14 - 17i =1 i + 17i =11=

• Verificação: É possível verificar se a função, t(n), encontrada

O processo de ordenação consiste em uma seleção sucessiva

Suponha o conjunto desordenado de elementos

Passo 1 32 7 28 43 5 72 92 Tamanho do segmento = 6

Passo 2 32 7 28 43 5 72 92 Tamanho do segmento = 5

Passo 3 32 7 28 5 43 72 92 Tamanho do segmento = 4

Passo 4 5 7 28 32 43 72 92 Tamanho do segmento = 3

Passo 5 5 7 28 32 43 72 92 Tamanho do segmento = 2

Passo 6 5 7 28 32 43 72 92 Tamanho do segmento = 1

Observe que o conjunto foi ordenado após 6 passos.

Algoritmo SelectSort (conjunto, n )

Algoritmo SelectSort (conjunto, n )

• Realizando a análise do bloco interno (pior caso):

2 + i =01 + 10i =11

+ 10n -10 + 7i =1 i + 

t(n) = 2 + n + 10n -10 + 7 (n − 1)n + (n – 1)

• Método da Seleção Direta

Suponha um conjunto de elementos dividido em dois

Pode-se então definir um algoritmo da inserção direta, como:

Suponha o conjunto desordenado de elementos

iniciando do final do conjunto

Passo 2 Observe que 43 já

Passo 3 Observe que 92 também

Observe que o conjunto ficou ordenado após 6 passos.

Método InsertionSort (A, tamanho = n)

Método InsertionSort (A, tamanho = n) Custo Vezes

• O tempo de execução do algoritmo é a soma dos tempos

• O melhor caso ocorre quando o vetor está ordenado na

• No melhor caso a avaliação de A[i]> chave sempre será

T(n) = c1n + c2 (n-1) + c3(n-1) + c4 (n-1) + c7 (n-1)

T(n) = (c1+ c2 + c3 + c4 + c7) n – (c2 + c3 + c4 + c7).