Complexidade de Algoritmos

Complexidade de Algoritmos Uma característica importante de qualquer algoritmo é seu tempo de execução é 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 242

Complexidade de Algoritmos 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: comparação de chaves movimentação de elementos troca de elementos As operações críticas escolhidas são as que consomem mais tempo 243

Complexidade de Algoritmos 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: do computador utilizado da linguagem e compiladores empregados e das condições locais de processamento 243

Complexidade de Algoritmos 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; } 252

Complexidade de Algoritmos 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 final 4 1 2 3 4 1 2 3 M A R I A M I R 253

Complexidade de Algoritmos 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 final 1 2 3 4 5 4 1 2 3 5 E S T A D O O S D A T E 254

Complexidade de Algoritmos 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]) 255

Complexidade de Algoritmos 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 a 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) 256

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

Complexidade Linear - O(n) 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); } }

Complexidade Quadrática - O(n2) Itens são processados aos pares, geralmente com um loop dentro do outro 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); } }

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

A notação O 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) 271

Alguns conceitos T (n) = O (1) : constante T (n) = O (log 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 (n2) : quadrático T (n) = O (nk) : polinomial no tamanho da entrada T (n) = O (kn), O (n!), O (nn) : exponencial – ruim!

Gráfico comparativo

Recursividade

Recursividade Um módulo recursivo é aquele que contém uma ou mais chamadas a si mesmo Programas recursivos: 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 232

Recursividade Todo processo recursivo consiste de duas partes: 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 232

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

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