4. Complexidade média Este capítulo considera a complexidade média, examinando casos ilustrativos de análise de algoritmos e de projeto de estruturas.   A complexidade média é, às vezes, o critério de avaliação mais apropriado, por exemplo quando se trata de um algoritmo usado freqüentemente. O desconhecimento das peculiaridades da aplicação em que o algoritmo será utilizado, refletido na dificuldade de determinação da distribuição das possíveis entradas, costuma tornar tal análise bastante difícil. A complexidade média de um algoritmo é uma média ponderada do desempenho de cada entrada pela probabilidade de ela ocorrer. Complexidade de Algoritmos

Dado um algoritmo a, sejam:   Dn o conjunto de suas entradas com tamanho n, prob(d) a probabilidade de ocorrer a entrada d de D, A complexidade média do algoritmo a é dada por)  Complexidade de Algoritmos

Visão geral do capítulo 4.1 Um exemplo clássico: Quicksort. Analisa o algoritmo de classificação Quicksort como um exemplo clássico de complexidade média, com distribuição uniforme.   4.2 Árvore de busca binária ótima. Examina árvore de busca binária ótima: um exemplo de armazenamento de dados utilizando um critério que tem como objetivo minimizar a complexidade média de procura. Complexidade de Algoritmos

4.1 Um exemplo clássico: QUICKSORT O algoritmo Quicksort classifica uma lista, particionando-a, classificando suas partes e depois concatenando as partes classificadas.   A idéia básica é escolher, de alguma maneira, um pivô e particionar a lista em relação ao pivô de maneira que todo elemento de uma das partes seja menor que qualquer elemento da outra parte. Este algoritmo classifica um vetor A em ordem não decrescente. O pivô será o maior entre os dois primeiros elementos diferentes em L, sendo zero se todos os elementos forem iguais entre si. Complexidade de Algoritmos

sorte V := vetor [ m..p ] de Elmord Algoritmo 4.1.1: Quicksort. Função Quicksort ( A : V, m, p : Nat )  A : V {ordenação por concatenação} {Entrada: vetor A[ m..p ].; Saída: vetor A : V (classificado em ordem ascendente).} sorte V := vetor [ m..p ] de Elmord 1. k  ind( pivô, A ); { inicializa k com índice do pivô } 2. se k = 0 { testa se todos os elementos são iguais entre si: 2 } 3. então retorne-saída ( A ) { vetor já está classificado } 4. senão { inicia classificação: 4 } 5. Troca( A[ m ], A[ k ] ); { troca primeiro com pivô } 6. Particionamento( A, j ); { particiona na posição j } 7. L'  Quicksort( A,  m, j - 1 ]; { classifica início (tamanho j - m) } 8. L"  Quicksort( A, j, p ]; { classifica final (tamanho p - j + 1) } 9. L  Concat( L', L" ); { concatena partes classificadas } 10. retorne-saída ( L ); { dá saída concatenada } 11. fim-senão; { 4: inicia classificação } 12. fim-se; { 2: k = 0? } 13. fim-Função. { fim do algoritmo Quicksort } Complexidade de Algoritmos

O desempenho de Quicksort com entrada A será dado por O desempenho de Quicksort com entrada A envolve as seguintes contribuições:   escolha do pivô e execução do algoritmo de Particionamento; Quicksort com a sublista da esquerda A [m .. j - 1 ] com tamanho i, i = j-m Quicksort com a sublista da direita A[ j .. p ] com tamanho n – i, n = p-m+1 . O desempenho de Quicksort com entrada A será dado por desemp[ Quicksort ](A, m, p) = desemp[ Pivô_Partic ](A) + + desemp[ Quicksort ](A, m, j - 1 ) + desemp[ Quicksort ](A, j, p ). onde, desemp[Pivô_Partic](A) ] é o desempenho da escolha do pivô e da execução do algoritmo Particionamento. Complexidade de Algoritmos

desemp[ Quicksort ]( A, m, p ) = desemp[ Pivô_Partic ]( A , m, p) + + desemp[ Quicksort ]( A, m, j - 1  ) + desemp[ Quicksort ]( A, j, p  ),   onde, desemp[ Pivô_Partic ]( A ) é o desempenho da escolha do pivô e do algoritmo Particiona. Sendo prob( i ) para a probabilidade de o pivô ser o ( i + 1 )ésimo elemento. Então cM[ Pivô_Partic ]( n ) é de ordem ( n ). Abreviando cM[ Quicksort ]( n ) por T( n ) Complexidade de Algoritmos

Como calculamos prob( i ) ? prob( i ) é a probabilidade de o pivô ser o ( i + 1 )ésimo elemento.   Supondo todos os elementos diferentes, o pivô será um dos dois primeiros elementos que aparecem na lista: o maior deles. Considere que: a probabilidade de qualquer elemento (1o, 2o, 3o, …, no) estar na primeira posição é . a probabilidade de o segundo element ser ser menor que ele é . Assim: a probabilidade de o pivô aparecer na primeira posição e ser o ( i + 1 )ésimo elemento será ; Complexidade de Algoritmos

A probabilidade de o pivô ser o ( i + 1 ) ésimo elemento teremos análogamente, a probabilidade de o pivô estar na segunda posição e ser o ( i + 1 )ésimo elemento será .   A probabilidade de o pivô ser o ( i + 1 ) ésimo elemento teremos Para n  1: ou seja Complexidade de Algoritmos

Simplificando a expressão:   Observe que, para qualquer função f de naturais, tem-se: Use essa propriedade com para mostrar que Complexidade de Algoritmos

Realmente, pode-se mostrar, por indução sobre n  1, que   Para resolver a equação de recorrência de T( n ), é conveniente ter-se uma candidata para T( n ), para usar indução. O melhor que se pode ter para complexidade média de um algoritmo de classificação é ( n . logn ), resultado que será provado mais adiante, no capítulo 6. Realmente, pode-se mostrar, por indução sobre n  1, que Complexidade de Algoritmos

O caso base (n = 2) é simples O caso base (n = 2) é simples. Supondo, como hipótese indutiva, T( i )  k . i . logi, para todo i  n, mostre que T( n )  k . n . logn. Alguns passos: Complexidade de Algoritmos

Complexidade de Algoritmos

Complexidade de Algoritmos

4.2 Árvore de busca binária ótima A árvore de busca binária ótima é um exemplo de armazenamento de dados.que privilegie os dados mais usados. Armazene, nas posições mais próximas da raiz, os dados mais procurados.   A estrutura é uma árvore binária e a procura é a partir da raiz, usando a estratégia da busca binária. Isto é, para qualquer nodo: “os elementos da subárvore da esquerda são menores que os elementos da subárvore da direita”. A questão é: dada uma seqüência ordenada de elementos, com probabilidades de procura conhecidas, obter uma tal árvore de busca binária ótima. Complexidade de Algoritmos Complexidade de Algoritmos 17

EXEMPLO: UMA POSSÍVEL ÁRVORE PARA REPRESENTAR S =  X1, X2, …, X9  É: Para isso, precisamos estabelecer a “raiz” da árvore. Conhecida a raiz, sabe-se que os elementos menores que a raiz ficarão na subárvore da esquerda, e os maiores, na subárvore da direita. EXEMPLO: UMA POSSÍVEL ÁRVORE PARA REPRESENTAR S =  X1, X2, …, X9   É: Complexidade de Algoritmos

Temos os custos das subárvores dados por: Os nodos redondos representando elementos presentes, e nodos quadrados, elementos ausentes.   Temos os custos das subárvores dados por: Para vértice redondo c( xi ) = prof( xi ) + 1; para vértice quadrado c( i ) = prof( i ). Complexidade de Algoritmos

A complexidade média de procura na árvore é: prob( x ) é a probabilidade de procura de um elemento x e c( x ) dá o número de comparações necessárias para achar x ou determinar que x  S.   prob( i ) é a probabilidade de procura de elementos x  S representados pelo vértice quadrado i profA profA se refere à profundidade na árvore A. Comparações necessárias: profA( xi ) + 1, para cada vértice redondo xi  S (i = 1, 2, …, n); profA( i ), para cada vértice quadrado x  S (i = 0, 1, …, n). Complexidade de Algoritmos

não depende da árvore. Portanto, deseja-se obter A que minimize: (4.2.2) Conhecida a raiz de A, digamos xr, Complexidade de Algoritmos

(4.2.3) onde AE e AD são as subárvores da esquerda e da direita, respectivamente. Complexidade de Algoritmos

Complexidade de Algoritmos

S' :=  x1, x2, …, xr-1  e S" :=  xr+1, xr+2, …, xn . Custo (A) = Custo( AE ) + Prob( AE ) + Custo( AD ) + Prob( AD ). O problema para S = < x1, x2, …, xn , a partir de uma escolha de raiz xr, passa a ter dois subproblemas, a saber para   S' :=  x1, x2, …, xr-1  e S" :=  xr+1, xr+2, …, xn  . Definindo: P[i, j] como o somatório de todas probabilidades associadas às árvores que correspondem a  xi+1, …, xj , S[i, r, j] como o custo da árvore correspondente a  xi+1, …, xj , com raiz xr e custo[i, j] como o custo mínimo para árvore correspondente a  xi+1, …, xj . Assim sendo, custo[i, i] = 0, Complexidade de Algoritmos

A questão fica na escolha adequada para r. Esse problema pode ser resolvido, construindo a solução a partir do subcaso. Custo[i, i] = 0 e P[i, i] = Prob(i), com i= 0, … , n   Segundo passo: S1 =  x1 , S2 =  x2 , …,  Sn =  xn . Complexidade de Algoritmos

No próximo passo, são seqüências com dois elementos: S1 =  x1, x2 , S2 =  x2, x3 , …,  Sn-1 =  xn-1, xn . Para S1 =  x1, x2 , há duas possibilidades, como mostra a figura 4.2.5.   Calculando S[0, 1, 2] ≔ custo[0, 0] + P[0, 0] + custo[1, 2] + P[1, 2], S[0, 2, 2] ≔ custo[0, 1] + P[0, 1] + custo[2, 2] + P[2, 2] e Complexidade de Algoritmos

{ árvore de busca binária ótima } custo[0, 2] = min [ S[0, 1, 2], S[0, 2, 2] ]. P[0, 2] independe do k escolhido entre k = 1 e k = 2. P[0, 2] ≔ P[0, k-1] + Prob(xk) + P[k, k] A cada passo são construídas subárvores maiores, até a alcançar a árvore original.   Algoritmo 4.2.1: Árvore de busca binária ótima No final, o índice correspondente à raiz da árvore estará em raiz[ 1, n ] e, a partir daí, a árvore inteira pode ser recuperada. Procedimento Árvore_Busca_Binária_Ótima algoritmo:Árvore_Busca_Binária_Ótima { árvore de busca binária ótima } { Entrada: Prob: M1 probabilidades de procura dos elementos ausentes na árvore, ProbX: M2 probabilidades de procura dos elementos presentes na árvore.} Saída: matriz raiz : M3 (raiz[ i, j ] é raiz de árvore ótima para  xi, …, xj ). } sorte M1 := vetor [ 0.. n  ] de IR+;  M2 := vetor [ 1.. n  ] de  +; M3 := vetor [ 0.. n, 1.. n ] de  +;  M4:= vetor [ 0.. n, 1.. n, 1.. n ] de  +; var {auxiliar} P, custo: M3 {matrizes}; S : M4 { matriz}; k {índice}; Complexidade de Algoritmos

1. para i de 0 até n faça {árvores de um nodo: quadrados 1} 2. custo[ i, i ]  0 ; {custo} 3. P[ i, i ]  Prob[ i ] {probabilidade} 4. fim-para ; {1: inicializações} 5. para s de 1 até n faça {varre altura s: 15} 6. para i de 0 até n - s faça {varre i: 14} 7. j  i + s ; {largura da árvore} 8. com S[ i, k, j ] := custo[i, k-1] + P[ i, k–1 ] + custo[ k, j ] + P[ k, j] (i  k  j) 9. determine k tal que S[ i, k, j ] seja mínimo para i  k  j 10. raiz[ i, j ]  k ; {raiz} 11. custo[ i, j ]  S[ i, j, k ] {custo} 12. P[ i, j ]  P[ i, k - 1 ] + ProbX[k ] + P[k,  j ] {probabilidade} 13. fim-com ; {8: S[ i, k, j ], para i  k  j } 14. fim-para ; {6: i de 0 até n - s} 15. fim-para {5: s de 1 até n} 16. pare-com-saída ( custo , raiz ) {dá saída} 17. fim-Procedimento {fim de Árvore_Busca_Binária_Ótima}   Complexidade de Algoritmos

4.3 Resumo do capítulo A finalidade deste capítulo é examinar a complexidade média, considerando casos ilustrativos de análise de algoritmos e de projeto de estruturas.   O desempenho desse algoritmo Quicksort depende crucialmente de qual elemento vem a ser o pivô, por isso teve que ser determinada a probabilidade de posição do pivô. Sua complexidade media com distribuição uniforme é de ordem O( n . logn ). Esse valor é ótimo para algoritmos de classificação, conforme será visto mais tarde. A árvore de busca binária ótima utiliza um critério que tem como objetivo minimizar a complexidade média de procura. O algoritmo utilizado usa o método de Programação Dinâmica, que sera visto no capítulo 5. Complexidade de Algoritmos