Análise de Algoritmos – Parte I

Profa. Eliane Oliveira Santiago

Critérios para escolher um bom
algoritmo
 Tempo de processamento.
 Quantidade de memória necessária para executar.

Eficiência de um algoritmo é medida em tempo de

execução ou espaço (memória) necessário à execução do
algoritmo (ou programa associado).

Tempo de execução de um algoritmo vaira com a entrada.

Tempo de Processamento
 Estudar o número de vezes que operações são
executadas é a melhor opção, visto que o tempo
gasto por um algoritmo depende do compilador e
do hardware (GPU, CPU, smartphones, etc).
Análise de Complexidade feita em
função de n
 n indica o tamanho da entrada
 Número de elementos no vetor
 Número de vértices num grafo
 Número de linhas de uma matriz
 Diferentes entradas podem ter custo diferentes
 Melhor caso
 Pior caso
 Caso médio
Função Constante f(n) = c
Para qualquer valor de n, a função constante
f(n) atribui um valor constante c.

A função constante mais fundamental é g(n) = 1.

f(n) = c pode ser escrita como uma constante c
que multiplica g(n), tal como f(n) = c.g(n)
Função Logaritmo f(n) = logbn
f(n) = logbn, para alguma constante b>1

x = logbn se, e somente se b1 = n

b= base do logaritmo
Função logaritmo
Calcular o menor inteiro maior ou igual a loga(n), pois este número é igual ao número de vezes que
se pode dividir n por a até que se obtenha um número menor ou a igual a 1.

Exemplo:
log327=3, porque 27/3/3/3 = 1.
log464=4, porque 64/4/4/4/4 = 1.

Por aproximação, temos log212 =4, porque 12/2/2/2/2 = 0,75 <=1.

A aproximação na base 2 surge na análise de algoritmo porque uma operação comum a muitos
algoritmos é dividir repetidamente uma entrada pela metada.
log(n) = log 2(n)
Função Linear f(n) = n
Dado um valor de entrada n, a função f atribui o valor n para si
mesma.

Exemplo: algoritmo de busca linear

A função linear representa o melhor tempo de execução que se

pode desejar obter para qualquer algoritmo que processa uma
coleção de n objetos que não estão na memória do computador,
uma vez que a própria leitura dos n objetos requer n operações.
Função Quadrática f(n) = n2
Dado um valor de entrada n, a função f atribuir o produto de n
por si mesmo.

Exemplos são algoritmos que possuem laços aninhados, onde o

laço interno executa uma quantidade linear de operações e o
laço mais externo é executado um número linear de vezes.
n * n operações = n2
Outras funções para análise de algoritmos
Função cúbica f(n) = n3
Função exponencial f(n) = nn
Arredondamento pra cima ou pra baixo
chão(x) = ao maior inteiro menor ou a igual a x
teto(x) = ao menor inteiro maior ou a igual a x

double x = 3.5;
int y = floor(x); // y=3
int z = ceil(x); // z=4
Análise de Algoritmos
Neste curso, estamos interessados em bons algoritmos e estruturas de dados.

De uma forma simples, uma estrutura de dados é uma forma sistemática de

organizar e acessar dados. E um algoritmo é um procedimento passo a passo
para executar alguma tarefa em tempo finito.

Estes conceitos são fundamentais para computação, mas para ser capaz de
classificar uma estrutura de dados ou algoritmo como sendo bom, são
necessárias formas de analisar os mesmos.
Análise de Algoritmos
Experimentos só podem ser feitos sobre um conjunto limitado de entradas de
teste.

Consequentemente, são deixados de fora os tempos de execução das entadas

não incluídas nos experimentos (e estas entradas podem ser importantes).

É difícil comparar os tempos de execução de dois algoritmos, a menos que os

experimentos sejam executados nos mesmos ambientes de hardware e
software. É necessário implementar e executa o algoritmo de maneira a
estudar seu tempo de execução experimentalmente.
Algoritmos de Pesquisas
Busca Linear complexidade linear O(n)
Busca Binária complexidade logaritmica O(lg(n))
 Algoritmo Interativo
Busca Linear
int buscaLinear(int v[], int tamanho_vetor, int valor){
int posicao = -1;
for(int indice=0; indice<tamanho_vetor; indice++){
if(v[indice] == valor){
return indice;
}
}
return posicao;
}
Algoritmo Interativo
Busca Binária int PesquisaBinaria
int esq = 0;
(int vet[], int chave, int Tam){

int dir = Tam-1;

int pivo;
while (esq <= dir){
pivo = (esq + dir)/2;
if (chave == vet[pivo]) return pivo;
if (chave < vet[pivo])
dir= pivo-1;
else
esq = pivo+1;
}
return -1; // valor (chave) não encontrado
}
Busca Binária
public class BinarySearch{
public static final int NOT_FOUND=-1;
public static int binarySearch(Comparable[] a, Comparable x) {
int low = 0;
int high = a.length-1;
int mid;
while(low<=high) {
mid = (low+high)/2;
if(a[mid].compareTo(x)<0)
low=mid+1;
public static void main(String[]args){
else if (a[mid].compareTo(x)>0) intSIZE=8;
high=mid-1; Comparable[] a = new Integer[SIZE];
else
for(int i=0;a[i] = new Integer(i*2);
return mid;
} for(inti=0;iSystem.out.println("Encontrado"+i+"em
"+
return NOT_FOUND;
binarySearch(a,newInteger(i)));
}
}
 1 static public int search1(int [] array, int target)
2 {
3 int high = array.length, low = -1, probe;
4 while (high - low > 1)
5 {
6 probe = (low + high) >>> 1;
7 if (array[probe] > target)
8 high = probe;
9 else

10 low = probe;
11 }
12 if (low == -1 || array[low] != target)
13 return -1;
14 else
15 return low;

16 }
Busca Binária
Implementação Recursiva
int PesquisaBinaria(int x, int v[], int e, int d){
int pivo = (e + d)/2;
if (v[pivo] == x) return pivo;
if (e > d) return -1; //não encontrado
else if (v[pivo] > x)
return PesquisaBinaria(x, v, pivo+1, d);
else
return PesquisaBinaria(x, v, e, pivo-1);
}
 Algoritmo Recursivo
Soma Linear de um vetor
public static int SomaLinear(int v[], int n){
if(n==1) return v[0];
return v[n-1]+SomaLinear(v, n-1);
}

public static void main(String[] args){

int v={10, 20, 30, 40, 50};
int soma_v = SomaLinear(v,5);
System.out.println(“Somatório do vetor v = “ + soma_v);
}
Algoritmo Recursivo de uma Soma
Binária
i = índice inicial
n = tamanho do vetor

o valor do parâmetro n é dividido a cada chamada recursiva

 Algoritmo Recursivo
Soma Binária em um vetor
public static int SomaBinaria(int v[], int i, int n){
if(n==1) return v[0];
return SomaBinaria(v, i, ceil(n/2) +
SomaBinaria(v,floor(n/2), n));
}

public static void main(String[] args){

int v={10, 20, 30, 40, 50};
int soma_v = SomaBinaria(v,3,5);
System.out.println(“Somatório do vetor v = “ + soma_v);
}
Problema das Torres de Hanoi
K-ésimo número de
Fibonacci
Qual dos algoritmos é mais eficiente?
K-ésimo número de
Fibonacci
Calculando o k-ésimo número de
Fibonacci usando Recursão Linear
 Exercícios
1. Escreva um programa Java que resultará em todos os subconjuntos de um conjunto de n
elementos (sem repetir nenhum conjunto).
2. Encontre um programa Java recursivo que encontre o menor e o maior valor de vetor de
inteiros sem usar nenhum laço.
3. Escreva um método recursivo Java que pega um String s e exibe seu inverso. Por exemplo,
o inverso de “pots&pans” será “snap&stop”.
4. Escreva um método recursive que determina se uma String s é um palíndromo, isto é, se é
igual ao seu inverso. Exemplo: ARARA (escrita da esquerda para a direita e da direita
para a esquerda é A-R-A-R-A.
Bibliografias
BÁSICA

 PEREIRA, Silvio do Lago. - Estruturas de Dados Fundamentais. - Ed. Érica, 2000.

 EDELWEISS, Nina; GALANTE, Renata. - Estruturas de Dados - Livros Didáticos Informática Ufrgs, V.18 – Ed. Bookman Companhia,
2009.
 SENAC Estruturas de Dados - 2001 - SENAC RIO.
COMPLEMENTAR
 CORMEN, T. LEISERSON, C.E., RIVEST, R. L. STEIN, C. Algoritmos – teoria e prática. – Ed. Campus, 2001.
 VELOSO, P., e outros. - Estruturas de Dados. - Ed. Campus.
 LAFORE, Robert - Estruturas de Dados e Algoritmos em Java. – Ed. Ciência Moderna, 2005.
 LORENZI, Fabiana; MATTOS, Patricia Noll de. ;
 CARVALHO, Tanisi Pereira de. - Estruturas de Dados. – Ed. Thomson Pioneira, 2006.
 WIRTH, Niklaus - Algoritmos e Estruturas de Dados – Ed. LTC, 1989. MORAES, Celso Roberto - Estruturas de Dados e Algoritmos –
Ed. Futura, 2003.
Bibliografias Complementares
http://www.tbray.org/ongoing/When/200x/2003/03/22/Binary

https://ai.googleblog.com/2006/06/extra-extra-read-all-about-it-
nearly.html

https://pt.khanacademy.org/computing/computer-science/algorithms/binary-
search/a/binary-search

https://pt.khanacademy.org/computing/computer-science/algorithms/binary-
search/a/implementing-binary-search-of-an-array
Bibliografias complementares
 SINGH, R. Java Queue Interface Tutorial with Examples. Disponível em
https://www.callicoder.com/java-queue/. Acesso em 29/04/2018.

 Outros sites
 http://introcs.cs.princeton.edu/43stack/
 https://www.geeksforgeeks.org/queue-interface-java/
 https://www.geeksforgeeks.org/priority-queue-class-in-java-2/
 http://www.tbray.org/ongoing/When/200x/2003/03/22/Binary