Complexidade de Algoritmos 1 Complexidade de Algoritmos l

Complexidade de Algoritmos 1

Complexidade de Algoritmos l Uma característica importante de qualquer algoritmo é seu tempo de execução – – l 2 é possível determiná-lo através de métodos empíricos, considerando-se entradas diversas é também possível obter este tempo a partir de métodos analíticos A análise dos algoritmos de ordenação e a busca encontra-se entre as mais conhecidas e utilizadas nos sistemas de computação

Complexidade de Algoritmos l Com freqüência, não se avalia a eficiência de tempo de uma ordenação por unidades de tempo, mas sim pelo número de operações críticas efetuadas: – – – l 5 comparação de chaves movimentação de elementos troca de elementos As operações críticas escolhidas são as que consomem mais tempo

Complexidade de Algoritmos l Métodos analíticos – – – objetivo: determinar uma expressão matemática que traduz o comportamento de tempo de um algoritmo. o resultado é uma fórmula dando o tempo médio (ou o número de operações) para ordenar um conjunto de tamanho n. o tempo de execução independente: l do 7 computador utilizado l da linguagem e compiladores empregados l e das condições locais de processamento

Complexidade de Algoritmos l Exemplo: Inversão de uma seqüência fim = n/2; for (i=0; i<fim; i++) { temp = S[i]; S[i] = S[n-1 -i]; S[n-1 -i] = temp; } 9

Complexidade de Algoritmos l n=5 – – – troca S[i] por S[n-1 -i] fim = 2 i = 0 troca S[0] por S[5 -1 -0] (S[4]) i = 1 troca S[1] por S[5 -1 -1] (S[3]) inicial 0 10 1 final 2 3 4 0 1 2 3 4 M A R I A A I R A M

Complexidade de Algoritmos l n = 6 troca S[i] por S[n-1 -i] – – fim = 3 i = 0 troca S[0] por S[6 -1 -0] (S[5]) i = 1 troca S[1] por S[6 -1 -1] (S[4]) i = 2 troca S[2] por S[6 -1 -2] (S[3]) inicial 11 final 0 1 2 3 4 5 E S T A D O 0 1 2 O D A 3 4 5 T S E

Complexidade de Algoritmos l n = 50 troca S[i] por S[n-1 -i] fim = 25 – i = 0 troca S[0] por S[50 -1 -0] (S[49]) – i = 1 troca S[1] por S[50 -1 -1] (S[48]) – i = 2 troca S[2] por S[50 -1 -2] (S[47]). . – i = 23 troca S[23] por S[50 -1 -23] (S[26]) – i = 24 troca S[24] por S[50 -1 -24] (S[25]) – 12

Complexidade de Algoritmos l O algoritmo executa exatamente as mesmas operações para seqüências de tamanho n – cada passo corresponde à troca de posição entre dois elementos da seqüência la 13 execução das três atribuições – o número de passos é igual ao número de vezes que executa o bloco for n/2, n>1 – Função: f(n) = 1 + 3(n)

Complexidade Constante - O(1) l Independe do tamanho de N (entradas) l É Executado em um número fixo de vezes Function Inicializa( tp_pilha *pilha) { pilha->topo = -1; } 16

Complexidade Linear - O(n) l Um número de operações será executado para cada N (entradas) function display(int X) { int i = 1; while (i<=X) { printf(“%d”, i*5); } 17 }

Complexidade Quadrática - O(n 2) Itens são processados aos pares, geralmente com um loop dentro do outro l function display(int X, int Y) { int i, j; for (i=1; i<=X; i++) for (j=1; j<= Y; j++){ printf(“%d”, i+j); } 18 }

A notação O l Complexidade – desprezar algumas operações interesse assintótico - termos de menor grau podem ser desprezados: n 2 + n será aproximado para n 2 l 6 n 3 + 4 n - 9 será aproximado para n 3 l l A função O atua como um limite superior assintótico da função f: – – – 19 – f f = = n 2 -1 403 5+2 logn +3 log 2 n 5*2 n +5*n 10 Þ Þ f f = = O(n 2) O(1) O(log 2 n) O(2 n)

A notação O l Algoritmo de inversão de seqüência: – o número de passos se mantém o mesmo para o mesmo valor de n variável independente é n efetua sempre n/2 passos – complexidade é O(n) – – 20

Alguns conceitos l l l l 21 T (n) = O (1) : constante T (n) = O (log n) : super-rápido T (n) = O (log n) : logarítmico – muito bom T (n) = O (n) : linear – toda a entrada é visitada T (n) = O (n log n) : limite de muitos problemas T (n) = O (n 2) : quadrático T (n) = O (nk) : polinomial no tamanho da entrada T (n) = O (kn), O (n!), O (nn) : exponencial – ruim!

Gráfico comparativo 22

Recursividade 23

Recursividade l l Um módulo recursivo é aquele que contém uma ou mais chamadas a si mesmo Programas recursivos: – – – 24 são mais concisos e normalmente menores podem ficar mais lentos por usar muitas posições de memória principal vantagem: poder utilizar funções recursivas para criar versões mais claras e simples, principalmente buscas e ordenações

Recursividade l Todo processo recursivo consiste de duas partes: – – 25 Solução Trivial: é conseguida por definição, ou seja, não é necessário fazer uso de recursividade para obtê-la Solução Geral: solução genérica que funciona em uma parte menor do problema original, mas que pode ser aplicada integralmente ao problema original

Recursividade Exemplo: Fatorial 1, se n=0 (solução trivial) l n! = n * (n-1)!, se n>0 (solução geral) l 26 4! 3! 2! 1! 0! = = = 4 3 2 1 1 * * 3! 2! 1! 0! recursão não recursão

Exemplo - Fatorial #include <stdio. h> int fat (int n); main( ) { int n, res; scanf("%d", &n); res=fat(n); printf("Fatorial: %dn", res); } int fat (int n) { if (n) /* (n != 0) */ return n * fat(n-1); else return 1; 27 } (1) res ? (2) res ? (3) res ? ? fat 3 n ? ? fat 0 1 2 3 n (4) res ? (5) res 6 1 ? ? ? fat 0 1 2 3 n 1 1 2 6 fat 0 1 2 3 n