Análise de Algoritmos e Estruturas

Introdução / Análise de complexidade - Conteúdo das Aulas
• Introdução as Estruturas de Dados e Algoritmos • Analise Grande O de Algoritmos
• Estruturas de dados e algoritmos • Complexidade de tempo
• Tempo de execução de algoritmos • Pior caso, caso médio e melhor caso
• Notação Grande O • Tipos comuns de complexidade de tempo
• Limites superiores • Tipos de dados abstratos (ADT)
Algoritmos e Estruturas de Dados 1

Aula 05 – Introdução / Análise de complexidade
• Representar dados eficientemente
• Estruturas de dados
• Métodos de representação de dados – forma de organizar dados
• Usados nas aplicações
• Arrays - Dados organizados linearmente / Posições de memória consecutivas
• Listas - Estrutura de dados linear
• Não armazena dados em posições de memória consecutivas
• Arvores – Não linear / Ordem hierárquica

• Escolha da estrutura de dados correta
• Afeta fortemente a eficiência de um programa

• Desenvolver um procedimento passo a passo
• Executar uma tarefa especifica
• Usado para desenvolver aplicações
• Algoritmos – especifica instruções passo a passo para solucionar um problema
• Algoritmos e estruturas de dados estão diretamente relacionados
• Algoritmos / Selecionar e usar uma estrutura de dados
• Estruturas de dados / Desenvolver algoritmos para várias operações da estrutura de

dados
• Pesquisar, ordenar, percorrer, etc.

Desenvolvimento de Programas
Estruturas de Dados Algoritmos

Representar Dados Eficientemente Desenvolver um procedimento passo a passo
Métodos de Representação de Dados Procedimentos que possuem os passos para

Arrays, Listas, Árvores execução de tarefas
Desenvolver algoritmos para várias operações Selecionar e usar uma estrutura de dados
em estruturas de dados

• Algoritmos
SOLUÇÃO A ALGORITMO A
SOLUÇÃO B ALGORITMO B
PROBLEMA MAIS EFICIENTE
SOLUÇÃO C ALGORITMO C
SOLUÇÃO D ALGORITMO D
• Eficiência
• Tempo de execução
• Memória

• Determinar o tempo de execução de um algoritmo
Implementa o algoritmo em uma linguagem
Dependente do software e hardware
Executa com diferentes entradas
Método Experimental Número limitado de entradas
Registra o tempo de execução exato
Não viável para algoritmos que possuem longos tempos de
execução
Determinar o tempo de
execução
Analisa o tempo de execução baseado no
tamanho das entradas
Método Analítico Independente de hardware e software
Considera todas as entradas possíveis
Análise Assintótica
• Notação Assintótica - Taxa de crescimento do algoritmo

• Analise Assintótica
• Tamanho da Entrada (n) Tempo de Execução
• Tamanho de entradas pequeno Menor tempo de execução
• Tamanho de entradas grande Maior tempo de execução
• Tamanho de entradas cresce Tempo de execução também cresce
• Tamanho de entradas dobra

Como o tempo de
• Tempo de execução pode dobrar / quadruplicar execução do algoritmo
cresce com o crescimento
• Aumentar 20 vezes / aumentar 100 vezes do tamanho de entradas

• Não importa o tempo de execução exato
• Importa o que acontece quando o tamanho de entradas se torna grande
• Importa o comportamento do algoritmo em relação a tamanho das entradas

Tamanho de entradas (n) 2 4 10 100 1000 10000

Algoritmo A 4 8 20 200 2000 20000
Algoritmo B 4 16 50 10000 1000000 100000000
• Para determinar a eficiência de um algoritmo
• Verificar como o algoritmo se comporta quando o tamanho de entradas cresce
• Encontrar a taxa de crescimento do tempo de execução
• Notação Grande O

• Grande O / Big O
• Ferramenta matemática mais usada para comparar a eficiência de algoritmos
• Comportamento assintótico de uma função
• Velocidade de crescimento de f(n) a medida que n cresce
• Examina a taxa de crescimento de uma função através da comparação com algumas
funções padrão cuja a taxa de crescimento é conhecida

• Definição
• é se existe uma constante e um , onde
• para todo
• Significa que a função não irá crescer mais rápido que a função para valores de
• é o limite superior da função

• Exemplos
𝒇 ( 𝒏 )=𝟓 𝒏+𝟒 𝒄=𝟔 𝒆 𝒏𝟎=𝟒

verificar se é da ordem de
Se existir uma constante e um tal que para todo
para todo
𝒈 (𝒏)=𝒏 é
• Similarmente
é
3é
é
45 é

• Exemplos
𝒇 ( 𝒏 )=𝟑 𝒏𝟐+ 𝟒 𝒏+𝟕 𝒄=𝟓 𝒆 𝒏𝟎=𝟔

obtendo as constantes apropriadas
𝟐
𝒈 (𝒏 ) =𝒏
• Similarmente
7
• Na prática não vamos encontrar a ordem de uma função dessa forma

• Limite superior /
• Algumas formas funcionais simples
• Contém um único temos em com o coeficiente 1
Taxa de Taxa de
crescimento baixa crescimento alta

𝒈(𝒏)
Valor de 𝒏
1 0 1 0 1 1 2
2 1 2 2 4 8 4
4 2 4 8 16 64 16
8 3 8 24 64 512 256
16 4 16 64 256 4096 65536
32 5 32 160 1024 32768 4.29E+09
64 6 64 384 4096 262144 1.84E+19
• é / é possui taxa de crescimento superior a

• Encontrando o grande O de uma função
Valor de
• 1 13,63% 18,18% 68,18%
• Contribuição do termo 10 84,50% 11,26% 4,22%

100 98,63% 1,31% 0,049%
1000 99,86% 0,13% 4,9E-04%
• Contribuição do termo
10000 99,98% 0,01% 4,9E-06%
• Contribuição do termo Analise Grande O valor da função com n crescendo

Quando se torna grande
Termo de maior crescimento se torna dominante
Termos menores e constante se tornam insignificantes

• Manter o termo com a maior taxa de crescimento e descartar os termos

menores e as constantes
• Ignorar os coeficientes
• Prova
Algumas constantes a e b vão existir de forma que

• para todo
Tornando a*C = c e n0 = b
• para todo
• Logo

Prova
• Se é constante, dizemos que • *1 para todo n
• A base do logaritmo não é importante

Prova

Taxa de Taxa de
crescimento crescimento
baixa alta

• Limites superiores
• é se existe uma constante e um , tal que
• para todo
• Para uma função existem várias funções de forma que

• seja
Limite superior aproximado
•é
• Limite superior distante

Correto pela definição mas não informativo
•

• Analise Grande O de Algoritmos
• Como usar a notação Grande O para analisar o tempo de execução de algoritmos
• Expressar o tempo de execução de um algoritmo como uma função do

tamanho de entrada
• Complexidade de tempo do algoritmo

• Encontrar o Grande O para a função

• Suponha 4 algoritmos para solucionar um problema/Processo de

comparação
Algoritmo A Algoritmo B Algoritmo C Algoritmo D

𝑇 ( 𝑛 ) =6 𝑛3 +log𝑛+ 2𝑛 𝑇 ( 𝑛 ) =5 𝑛+𝑛2 + 4 𝑇 ( 𝑛 ) =log 𝑛+5 𝑛+10 𝑇 ( 𝑛 ) =3 𝑛2 +15
(𝑛3 )
𝑂encontra-se
Primeiro (𝑛2 ) os algoritmos - representa
a função𝑂para 𝑂 (𝑛) (𝑛2 )
o tempo de𝑂execução do algoritmo
em termos do tamanho de entradas
Comparar
O algoritmo
asnão
taxas
é eficiente
de crescimento
se o tempo
dos tempo
de execução
de execução/Comparar
crescer muito rápido
as taxas
em relação
de crescimento
ao tamanho
das
funções
de entradas

• Calcular a Complexidade de Tempo
• O tempo de execução é proporcional ao número de operações primitivas

executadas
• Comparações
• Operações aritméticas
• Atribuições
• Entrada/Saída (I/O)

• Para encontrar a função - expressar o numero de operações primitivas em

tempo de execução, em termos de
AlgoritmoQualquer(Inteiro n) Análise assintótica
Encontrar a função que representa o tempo de execução
{ •em termos
Não está
deinteressada em quanto tempo a operação leva
entrada C1 para executar
C2
𝑇 ( 𝑛 ) =𝐶 1+𝐶2+𝐶
• O processamento exato da3 função
∗𝑛+𝐶não4 é
atribuicao necessário
• Interessada em quantas vezes a operação é executada
para (i recebe 0; i menor n; incrementa i) Encontra
• Escritao da
Grande
função O para essa função
comparacao C3 • Remover constantescom aquelas operações primitivas
• Preocupa-se
• Ignorarcujo
os coeficientes
o número depende do tamanho de entrada
operacao_aritmetica C4 • Operações em laços cujo o número de
} 𝑂 (𝑛) de n
iterações depende
Interessada em saber o que acontece quando o tamanho de
entradas se tornaalgoritmos
Permite analisar muito grande
de maneira independente do
computador

AlgoritmoQualquer(Inteiro n) 𝑇 ( 𝑛 ) =( 𝑛−2 ) +𝑛=2 𝑛− 2
{
atribuicao
para (i recebe n-2;
𝑇 ( 𝑛 ) =𝑂(𝑛)
i maior ou igual a 1;
decrementa i)
operacao_aritmetica
saída
para (i recebe 0;
i menor n;
incrementa i)
comparação
para (i recebe 0;
i menor 6;
incrementa i)
atribuicao
}

AlgoritmoQualquer(Inteiro n) 𝑇 ( 𝑛 ) =[𝑛/ 4]
{
entrada
𝑇 ( 𝑛 ) =𝑂(𝑛)
para (i recebe n;
i recebe i-4)
operacao_aritmetica
saída
}

AlgoritmoQualquer(Inteiro n) 𝑇 ( 𝑛 ) =[𝑛/5]
{
entrada
𝑇 ( 𝑛 ) =𝑂(𝑛)
para (i recebe 1;
i menor ou igual a n; Complexidade de tempo – em laços onde a varável de
i recebe i+5) controle é incrementada ou decrementada por uma
comparacao constante total é
saída
}

AlgoritmoQualquer(Inteiro n) Considerando laços nos quais a variável de controle é
{ dividida ou multiplicada por uma constante
atribuicao
Iteração
para (i recebe n-1;
i maior ou igual a 1; 50
i recebe i/2)
operacao_aritmetica 25
saída
12
} 6
3
1
0
𝑇 ( 𝑛 ) =[log 2 𝑛] 𝑇 ( 𝑛 ) =𝑂 ¿
AlgoritmoQualquer(Inteiro n) Considerando laços nos quais a variável de controle é

{ dividida ou multiplicada por uma constante
atribuicao
Iteração
para (i recebe 1;
i menor que n; 1
i recebe i*2)
operacao_aritmetica 2
saída
4
} 8
10
32
64
𝑇 ( 𝑛 ) =[log 2 𝑛] 𝑇 ( 𝑛 ) =𝑂 ¿
AlgoritmoQualquer(Inteiro n) Considerando laços aninhados

{ • Verificar quantas vezes o laço mais interno executa
entrada • Á quantidade de iterações no laço mais interno serão
sempre mais que do laço externo
para (i recebe 0; O laço externo vai executar vezes
i menor que n; Para cada iteração do laço externo o laço interno vai
incrementa i) executar vezes
atribuicao Número total de iterações do laço interno
para (j recebe 0;
j menor que n;
incrementa j)
𝑇 ( 𝑛 ) =𝑛+𝑛2 𝑇 ( 𝑛 ) =𝑂 ¿
comparacao
operacao_aritmetica
saída
}

AlgoritmoQualquer(Inteiro n) 𝑇 ( 𝑛 ) =n log 𝑛+𝑛2
{
entrada
𝑇 ( 𝑛 ) =𝑂 ¿
para (i recebe 0;
i menor que n;
incrementa i)
para (j recebe n-1;
j maior ou igual a 1;
j recebe j/2)
operacao_aritmética
para (k recebe 0;
k menor que n;
incrementa k)
comparacao
operacao_aritmetica
saída
}

AlgoritmoQualquer(Inteiro n) 𝑇 ( 𝑛 ) =𝑛3 +10 𝑛
{
entrada
𝑇 ( 𝑛 ) =𝑂 ¿
para (i recebe 0; i menor que n;
incrementa i)
para (j recebe 0; j menor que n;
incrementa j)
para (k recebe 0; k menor que n;
incrementa k)
comparação
operacao_aritmetica

incrementa i)
para (j recebe 10; j maior ou igual a 1;
decrementa j)
atribuicao
}

AlgoritmoQualquer(Inteiro n) Laços aninhados em que as iterações dos laços internos
{ dependem do índice do laço externo
atribuicao • Nesta caso não se encontra o número total de
iterações do laço interno apenas multiplicando as
para (i recebe 0; iterações dos laços internos e externos
i menor que n;
incrementa i) Iterações do laço externo Valor de i Número de iterações do
laço interno
para (j recebe 0; 0 1
j menor ou igual a i;
incrementa j) 1 2
operacao_aritmetica
2 3
saída
}
𝑛 ( 𝑛+1 )
𝑁 ú 𝑚𝑒𝑟𝑜 𝑡𝑜𝑡𝑎𝑙 𝑑𝑒 𝑖𝑡𝑒𝑟𝑎 çõ 𝑒𝑠 𝑛𝑜 𝑙𝑎ç 𝑜𝑖𝑛𝑡𝑒𝑟𝑛𝑜=1+2+3+…+𝑛=
2
𝑛2 𝑛
𝑇 ( 𝑛) = +
2 2 𝑇 ( 𝑛 ) =𝑂 ¿


para (i recebe 0; iterações dos laços internos e externos
i menor que n-1;
incrementa i) Iterações do laço externo Valor de i Número de iterações do
laço interno
para (j recebe i+1; 0

j menor que n;
incrementa j) 1
operacao_aritmetica
2
saida
}
𝑛 ( 𝑛 −1 ) 2
𝑁 ú 𝑚𝑒𝑟𝑜 𝑡𝑜𝑡𝑎𝑙 𝑑𝑒 𝑖𝑡𝑒𝑟𝑎 çõ 𝑒𝑠 𝑛𝑜 𝑙𝑎ç 𝑜𝑖𝑛𝑡𝑒𝑟𝑛𝑜= ( 𝑛− 1 ) + ( 𝑛− 2 ) +…+2+1=
2 1
2
𝑛 𝑛
𝑇 ( 𝑛) = −
2 2 𝑇 ( 𝑛 ) =𝑂 ¿ Algoritmo de ordenação por seleção

para (i recebe n-2; iterações dos laços internos e externos
decrementa i) Iterações do laço externo Valor de i Número de iterações do
laço interno
para (j recebe 0;
j menor ou igual a i;
incrementa j)
operacao_aritmetica
saida
}
𝑛 ( 𝑛 −1 ) 1 2
𝑁 ú 𝑚𝑒𝑟𝑜 𝑡𝑜𝑡𝑎𝑙 𝑑𝑒 𝑖𝑡𝑒𝑟𝑎 çõ 𝑒𝑠 𝑛𝑜 𝑙𝑎ç 𝑜𝑖𝑛𝑡𝑒𝑟𝑛𝑜= ( 𝑛− 1 ) + ( 𝑛− 2 ) +…+2+1=
2 0 1
2
𝑛 𝑛
𝑇 ( 𝑛) = −
2 2 𝑇 ( 𝑛 ) =𝑂 ¿ Algoritmo de ordenação bolha

AlgoritmoQualquer(Inteiro n) 𝑇 ( 𝑛 ) =𝑛log 𝑛
{
atribuicao
𝑇 ( 𝑛 ) =𝑂 ¿
para (i recebe 0;
i menor n;
incrementa i)
função(i) 𝐎¿
saida
}

AlgoritmoQualquer(Inteiro n) Possui instruções if/else
{ • Considera o bloco com ordem maior
incrementa i)
para (j recebe n-1; j maior ou igual a 1;
𝑇 ( 𝑛 ) =𝑛log 𝑛+𝑛2
j recebe j/2)
operação_aritmetica 𝑇 ( 𝑛 ) =𝑂 ¿
se (condicao)
incrementa i)
para (j recebe 0; j menor que n;
incrementa j)
comparacao
senao
incrementa i)
operacao_aritmetica
}

AlgoritmoQualquer(Inteiro n) Alguns algoritmos realizam o mesmo número de
{ operações sempre que são executados
atribuicao • Tempo constante
para (i recebe 0; i menor que 5;

incrementa i) 𝑇 ( 𝑛 ) =𝑂 ¿
operacao_aritmetica
exibirPrimeiroElemento()
saida
}
trocarPrimeiroUltimoElemento()
retornarTamanhoPilha()

• Pior caso, caso médio e melhor caso
• Tempo de execução de um algoritmo depende da quantidade de entradas
• Alguns algoritmos possuem tempo de execução diferentes para diferentes

entradas do mesmo tamanho
• Nesses algoritmos o tempo de execução depende também do dado de entrada

• Caso médio
• Tempo médio de execução do algoritmo para o tamanho de entradas
• Considera todas as possíveis entradas e calcula a média
• Distribuição de probabilidade dos dados de entrada / todas a possibilidades

de entrada são igualmente prováveis
• Raramente feito / Difícil de determinar

• Melhor caso BuscaLinear(a[], n, x)

{
• Menor tempo de execução do incrementa i)
se a[i] igual x
algoritmo para o tamanho de retorna i
entradas retorna -1
}
• Considera uma entrada na qual o
algoritmo leva o menor tempo
• Não é muito informativo

• Pior caso BuscaLinear(a[], n, x)

{
• Tempo de execução máximo do incrementa i)
se a[i] igual x
algoritmo para o tamanho de retorna i
entradas 𝑛 retorna -1
}
• Considera uma entrada onde o
algoritmo executará no maior Algoritmo A
tempo Pior caso ->
Caso médio ->
• Em geral é o usado / Informativo Melhor caso ->
Algoritmo A é

• Tipos comuns de complexidade de tempo
O(1) Constante • Todas as operações são executadas uma única vez ou um número fixo de vezes
• Leva o mesmo tempo para qualquer tamanho de entrada
• Exemplo: inserir um novo elemento no inicio de uma lista ligada
O(log n) Logarítmico • Algoritmos que solucionam problemas dividindo-os em problemas menores
• Reduzem o número de elementos considerado em cada passo
• Exemplo: algoritmo de busca binária
O(n) Linear • Cada elemento da entrada é processado de alguma forma
• Tempo de execução é linearmente proporcional a n
• Se o tamanho de entradas dobra o tempo de execução também dobra
• Exemplo: algoritmo para exibir todos os elementos de uma array / algoritmo para inserir um novo elemento no final de uma lista ligada
O(n log n) Logarítmico Linear • Exemplo: algoritmo de ordenação merge sort
O() Quadrático • Processa todos os pares de itens de dados de entrada

• Se n dobra o tempo de execução quadruplica
• Ocorre geralmente em algoritmos que envolvem iterações aninhadas sobre as entradas
• Exemplo: algoritmos de ordenação bolha e de ordenação por seleção
O() Cubico • Ocorre quando o algoritmo processa dos dados de entrada em agrupamento de três
• Exemplo: Multiplicação de matrizes
O() Polinomial • O tempo de execução para este algoritmo cresce muito rapidamente
O() Exponencial • O tempo de execução para este algoritmo cresce muito rapidamente
• Exemplo: algoritmo com onde irá dobrar para cada elemento adicional nos dados de entrada
• Problema das torres de Hanoi

• Tipos de dados abstratos (ADT)
• Modelo/conceito que define um tipo de dados logicamente
• Especifica um conjunto de dados
• Especifica um conjunto de operações que podem ser executadas sobre os dados
• Não especifica como essas operações são implementadas
• Não especifica como os dados serão organizados em memória
• Não especifica quais algoritmos serão usados para implementar as
operações

• Tipos de dados abstratos (ADT)
• Existe como uma ideia
• Não possui existência física
• Modelo teórico / visão independente de implementação do tipo de dado

• Tipo de dados abstrato Lista
• Contém elemento de mesmo tipo organizados sequencialmente

• inicializar()/initialize() – inicializa a lista inicialmente vazia
• obter()/get() – retorna um elemento da lista de uma posição especificada
• inserir()/insert() – insere um novo elemento em qualquer posição da lista
• remover()/remove() – remove a primeira ocorrência de qualquer elemento de uma lista não vazia
• removerEm()/removeAt() – remove o elemento da posição especificada na lista
• substituir()/replace() – substitui um elemento em qualquer posição por outro elemento
• tamanho()/size() – retorna o numero de elementos na lista
• estaVazia()/isEmpty() – retorna verdadeiro se a lista esta vazia, senão retorna falso
• estaCheia()/isFull() – retorna verdadeiro se a lista esta cheia, senão retorna falso

• Tipo de dados abstrato Pilha

• inicializar()/initialize() – inicializa a pilha inicialmente vazia
• empilhar()/push() – insere um elemento em uma extremidade da pilha chamada topo
• desempilhar()/pop() – remove e retorna o elemento no topo da pilha
• exibir()/peek() – retorna o elemento no topo da pilha sem removê-lo
• tamanho()/size() – retorna o numero de elementos na pilha
• estaVazia()/isEmpty() – retorna verdadeiro se a pilha esta vazia, senão retorna falso
• estaCheia()/isFull() – retorna verdadeiro se não for possível empilhar novos elementos

• Tipo de dados abstrato Fila

• inicializar()/initialize() – inicializa a fila inicialmente vazia
• enfileirar()/enqueue() – insere um elemento no final da fila
• desenfileirar()/dequeue() – retorna e remover o primeiro elemento da fila
• exibir()/peek() – retorna o primeiro elemento da fila sem removê-lo
• tamanho()/size() – retorna o numero de elementos na fila
• estaVazia()/isEmpty() – retorna verdadeiro se a fila esta vazia, senão retorna falso
• estaCheia()/isFull() – retorna verdadeiro se não for possível inserir novos elementos

• Implementações físicas dos tipos de dados abstratos
• Tipo de dado abstrato -> visão lógica dos dados\
• Operações para manipular os dados (O quê)
• Estrutura de dados -> representação concreta dos dados
• Algoritmos para manipular os dados (Como)

• Tipos de dados abstratos – linguagem de especificação das estruturas de dados
• Usuário da estrutura de dados – Cliente
• Especificação da ADT – Interface / Único artefato visível aos clientes

Análise de Algoritmos e Estruturas

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

Análise de Algoritmos e Estruturas

Enviado por

Direitos autorais:

Formatos disponíveis

Introdução / Análise de complexidade - Conteúdo das Aulas

• Introdução as Estruturas de Dados e Algoritmos • Analise Grande O de Algoritmos

• Estruturas de dados e algoritmos • Complexidade de tempo

• Tempo de execução de algoritmos • Pior caso, caso médio e melhor caso

• Notação Grande O • Tipos comuns de complexidade de tempo

• Limites superiores • Tipos de dados abstratos (ADT)

Algoritmos e Estruturas de Dados 1

• Métodos de representação de dados – forma de organizar dados

• Usados nas aplicações

• Arrays - Dados organizados linearmente / Posições de memória consecutivas

• Listas - Estrutura de dados linear

• Não armazena dados em posições de memória consecutivas

• Arvores – Não linear / Ordem hierárquica

Algoritmos e Estruturas de Dados 2

• Afeta fortemente a eficiência de um programa

Algoritmos e Estruturas de Dados 3

• Usado para desenvolver aplicações

• Algoritmos – especifica instruções passo a passo para solucionar um problema

• Algoritmos e estruturas de dados estão diretamente relacionados

• Algoritmos / Selecionar e usar uma estrutura de dados

• Estruturas de dados / Desenvolver algoritmos para várias operações da estrutura de

Algoritmos e Estruturas de Dados 4

Estruturas de Dados Algoritmos

Métodos de Representação de Dados Procedimentos que possuem os passos para

Algoritmos e Estruturas de Dados 5

Algoritmos e Estruturas de Dados 6

• Notação Assintótica - Taxa de crescimento do algoritmo

Algoritmos e Estruturas de Dados 7

• Tamanho da Entrada (n) Tempo de Execução

• Tamanho de entradas pequeno Menor tempo de execução

• Tamanho de entradas grande Maior tempo de execução

• Tamanho de entradas cresce Tempo de execução também cresce

• Tamanho de entradas dobra

Algoritmos e Estruturas de Dados 8

• Não importa o tempo de execução exato

• Importa o que acontece quando o tamanho de entradas se torna grande

• Importa o comportamento do algoritmo em relação a tamanho das entradas

Algoritmos e Estruturas de Dados 9

Tamanho de entradas (n) 2 4 10 100 1000 10000

• Para determinar a eficiência de um algoritmo

• Verificar como o algoritmo se comporta quando o tamanho de entradas cresce

• Encontrar a taxa de crescimento do tempo de execução

Algoritmos e Estruturas de Dados 10

Algoritmos e Estruturas de Dados 11

• é o limite superior da função

Algoritmos e Estruturas de Dados 12

𝒇 ( 𝒏 )=𝟓 𝒏+𝟒 𝒄=𝟔 𝒆 𝒏𝟎=𝟒

Algoritmos e Estruturas de Dados 13

𝒇 ( 𝒏 )=𝟑 𝒏𝟐+ 𝟒 𝒏+𝟕 𝒄=𝟓 𝒆 𝒏𝟎=𝟔

Algoritmos e Estruturas de Dados 14

• Algumas formas funcionais simples

• Contém um único temos em com o coeficiente 1

Algoritmos e Estruturas de Dados 15

Algoritmos e Estruturas de Dados 16

• Contribuição do termo 10 84,50% 11,26% 4,22%

• Contribuição do termo Analise Grande O valor da função com n crescendo

Algoritmos e Estruturas de Dados 17

• Manter o termo com a maior taxa de crescimento e descartar os termos

Algumas constantes a e b vão existir de forma que

Algoritmos e Estruturas de Dados 18

• A base do logaritmo não é importante

Algoritmos e Estruturas de Dados 19

Algoritmos e Estruturas de Dados 20