Algoritmos de Pesquisa

Transcrição

1 Algoritmos de Pesquisa Hugo Santos Miguel Fonseca 11 Abril 004 Conteúdo 1 Descrição dos algoritmos 1.1 Pesquisa sequencial Pesquisa Binária Pesquisa Ternária Analise de Complexidade 3.1 Pesquisa Sequencial Pior Caso Caso Médio Pesquisa Binária Pior Caso Caso Médio Pesquisa Ternária Pior Caso Caso Médio Analise Comparativa 6 A Implementação utilizada 8 A.1 impl.c A. tests.sh

2 Filhos a Esquerda Valores Inferiores No Pai Filhos a Direita Valores Superiores Figura 1: Partição do vector na pesquisa binária Descrição dos algoritmos 1.1 Pesquisa sequencial Figura : Codificação de uma árvore binária num vector ordenado O algoritmo de pesquisa sequencial envolve uma comparação elemento a elemento desde a primeira até à última posição do vector. Uma vez que o vector de entrada se encontra ordenado, quando a condição x > vect(k), onde x é o valor a ser pesquisado e k a posição corrente no vector, se verifica, consideramos imediatamente que o valor não se encontra no vector. 1. Pesquisa Binária Este algoritmo implementa o mesmo comportamento da pesquisa numa Árvore Binária, considerando que esta árvore se encontra codificada no vector de entrada (ver Figura ). Este algoritmo supõe que todos os nós descendentes do filho esquerdo (inclusivé) têm valor inferior ao valor do nó pai enquanto que os nós descendentes do filho direito (inclusivé) têm valor superior. Esta suposição é a base do algoritmo de pesquisa binária, seguindo a codificação da árvore binária, os filhos à esquerda correspondem uma partição do vector enquanto que os valores à direita correspondem a outra partição (ver Figura 1). Para um vector de tamanho n a profundidade máxima d da árvore será de d = log (n + 1), uma vez que o número máximo de elementos numa árvore de profundidade d é n = d Pesquisa Ternária A pesquisa ternária tem um comportamento semelhante à pesquisa binária relativamente à partição iterativa do vector de entrada. Cada partição é particionada em três sub-partições e os valores nas posições m 3 e m 3, onde m é o tamanho da partição, são comparados ao valor que está a ser pesquisado (ver Figura 3). Caso um destes

3 Valores menores que A A Valores entre A e B B Valores maiores que B Figura 3: Partição do vector na pesquisa ternária valores seja o valor que está a ser pesquisado o valor foi encontrado, senão continuamos o algoritmo numa das sub-partições. Caso a partição tenha um tamanho nulo o valor nao foi encontrado e se tiver tamanho unitário existe apenas uma folha e deve ser apenas comparado o valor nessa posição. O número de ciclos que o algoritmo vai executar (profundidade da árvore) é dado por log 3 (n + 1) Analise de Complexidade Tendo em conta que D n = { conjunto das possiveis instancias de um problema com tamanho n I D n, sendo I uma instância particular Considerando também p(i) - probabilidade de uma ocorrência e t(i) - número de operações para a instância I, ficamos com:.1 Pesquisa Sequencial.1.1 Pior Caso Pior Caso: W(n) = max t(i), com I D n Caso Médio: A(n) = p(i)t(i). com I D n No algoritmo de pesquisa sequencial, para uma entrada ordenada, o pior caso ocorre quando o elemento a pesquisar não existe no vector e é maior que qualquer elemento do vector (x > max(vect), onde x é o valor a ser pesquisado). Neste caso o algoritmo vai percorrer e compararar os valores em todas as posições do vector de entrada. Adicionalmente, caso o elemento a ser pesquisado se encontre na ultima posição do vector, também irão ser feitas o mesmo número de comparações e como tal esta situação é equivalente ao elemento nao existir. Seja n o tamanho do vector temos que logo W(n) = n W(n) O(n).1. Caso Médio Consideramos uma classe possivel: I k primeira ocorrência na k-esima posição, com k = 0, 1,..., n 1 Na class I k o algoritmo efectua t k = k + 1 comparações. Todas as ocorrências sao equiprovaveis, como tal têm probabilidade 1 n. n 1 A(n) = p(i k )t(i k ) k=0 3

4 n 1 1 A(n) = (k + 1) n k=0 A(n) = 1 n 1 (k + 1) n A(n) = 1 n k=0 ( n (n + 1) ) A(n) = 1 (n + 1) Logo. Pesquisa Binária..1 Pior Caso A(n) O(n) No algoritmo de pesquisa binária o pior caso ocorre mais uma vez quando o elemento a pesquisar não existe no vector de entrada e é também maior que qualquer valor da entrada (x > max(vect), onde x é o valor a ser pesquisado). É também Pior Caso quando o elemento a ser pesquisado é a ultimo elemento do vector uma vez que é uma situação que vai resultar no mesmo número de comparações. Vamos considerar inicialmente uma entrada de tamanho unitário. Para esta instância W(1) = ( comparações, x = vector(k) e x < vector(k)). Para n = n = 3 temos já uma árvore de profundidade. As comparações serão feitas na raiz e na folha. O caso para a folha foi já analizado, é W(1). Este caso mais o número de comparações na raiz (outras comparações) resultam em 4 comparações. Chegamos então à conclusão que vamos ter comparações por cada nó que visitamos, ou seja W(n) = W(1) profundidade arvore Especificámos inicialmente que a profundidade da árvore é dada por d = log (n + 1), o que resulta em Resultando em W(n) = W(1) log (n + 1) W(n) = log (n + 1) W(n) O(log (n)).. Caso Médio Considerando que a probabilidade de x < vect(k), onde x é o valor a ser pesquisado e k é a raiz da sub-árvore da iteração corrente, é igual a x > vect(k), em cada iteração são feitas 1+ = 3 comparações. k A(n) = (i + 1) n i i=0 j=1 Onde i representa o nível da árvore, ou iteração do algoritmo e j o número de nós no nível i. A(n) = A(n) = k 1 i=0 k 1 i=0 i 1 n (i + 1) j=1 3 1 n (i + 1)3 i k 1 (i + 1) i n i=0 4

5 Como k = log (n + 1) ( k 1 ) k 1 i + i i n n i=0 i=0 ( ( k 1) + ( + k (k )) ) n ( k (k 1) + 1 ) n ((n + 1)(log (n + 1) 1) + 1) n (nlog (n + 1) n + log (n + 1)) Concluindo n (n (log (n + 1) 1) + log (n + 1)) ( log (n + 1) 1 + log ) (n + 1) n ( ) 3 A(n) O log (n).3 Pesquisa Ternária.3.1 Pior Caso Mais uma vez o pior caso corresponde à pesquisa de um valor superior ao ultimo valor do vector, ou seja, x > max(vect). Consideramos inicialmente a maior instância em que esta situação se verifique e em que vai resultar apenas numa iteração. Temos então que n = 3, em que são feitas 4 comparações (pior caso em número de comparações numa só iteração). Usando a mesma estratégia que foi utilizada anteriormente, para n > 3, teremos o mesmo comportamento por partição que obtemos para o vector de n = 3. Teremos então que o pior caso W(n) = 4 número de partições k Como n = 3 k 1 temos Concluindo E ( ) n + 1 k = log 3 ( ) n + 1 W(n) = 4 log 3 W(n) 4log 3 ( n ).3. Caso Médio No algoritmo de pesquisa ternária, em cada iteracção temos cinco situacções distintas: x < vect(k 1 ), x = vect(k 1 ), vect(k 1 ) < x < vect(k ), x = vect(k ) e x > vect(k ). Vamos considerar que estas cinco situações são equiprovaveis, ou seja, p = 1 5. A cada situação está também associado num número de comparações distinto, sendo 1 para a primeira, para a segunda, 3 para a terceira e finalmente 4 comparações para as quarta e quinta situações. Para as instâncias que resultam apenas numa iteracção o número médio de comparações é então =

6 Sabendo o número médio de iteracções poderemos depois saber A(n). Uma vez que n = 3 k 1 ( ) n + 1 k = log 3 O número médio de iteracções vem quando m = n, então ( n k medio = log + 1 ) 3 A(n) = 14 5 k medio = 14 ( n ) 5 log 3 4 Concluimos que 3 Analise Comparativa A(n) 14 ( n ) 5 log 3 4 Tendo já efectuado uma série de experiência conclusivas e uma análise analitica aos algoritmos em estudo falta-nos ainda uma análise comparativa entre os vários algorimos. Devido à sua natureza linear, o algoritmo de pesquisa sequencial e bastante mau e não escala, tanto para entradas pequenas como grandes terão que ser feitas até n comparações para decidir se um determinado valor pertence ou não à entrada. Para a maior parte das aplicações este algoritmo não é aceitavel, para um vector de elementos serão feitas comparações. A sua inclusão neste trabalho serve meramente de exemplo uma abordagem não optimizada. Não são apresentados gráficos para este algoritmo pois é claro o seu comportamento linear médio e constante no pior caso. Embora pudesse prometer à partida devido à sua escalabilidade em log3(n) relativamente à entrada, o algoritmo de pesquisa ternária revelou-se uma pior escolha relativamente ao binário. Embora o número de iterações necessárias para uma determinada entrada seja menor, log3(n) vs. log(n), as condições necessárias ao algoritmo rapidamente elevam o número de comparações relativamente ao binário. Isto deve-se principalmente ao facto de se ter que escolher um de três ramos, enquanto no binário temos apenas que decidir uma de duas direcções. Na Figura 4 podemos observar o comportamento do algoritmo em entradas com vários tamanhos relativamente ao caso médio experimental, analitico e também ao pior caso. Como já foi referido, o algoritmo de pesquisa binária é o que obtem o melhor resultado nos parametros em análise. Ele é também o que escala melhor, necessitando cerca de 30 comparações em média para uma entrada de , e cerca de 40 comparações para uma entrada de posições. Na Figura 5 podemos observar o crescimento logaritmico tanto para o pior caso como para o caso médio relativamente ás entradas fornecidas previamente. Embora o número de comparações médio da pesquisa binária não seja muito menor que o da ternária, se observar-mos o pior caso já não podemos afirmar o mesmo, com a ternária a ter uma relação de 5 40 (medio pior) enquanto que o binário tem 3 para entradas de elementos. Nos gra ficos apresentados, o pior caso representa o pior caso descrito para os vários algoritmos (elemento não existir e ser superior a todos os elementos do vector) enquanto que o caso médio representa a média do número de comparações que foram efectuadas para todos os elementos do vector. 6

7 40 Exp. Ternary Worst Case Ternary Average Ternary Figura 4: Análise comparativa da experiência para o algoritmo de pesquisa ternária 35 Exp. Binary Worst Case Binary Analysis Avg Binary O(3/ log(n)) Figura 5: Análise comparativa da experiência para o algoritmo de pesquisa binária 7

8 A Implementação utilizada A.1 impl.c # i n c l u d e < s t d i o. h> # i n c l u d e < s t r i n g. h> # i n c l u d e < s t d l i b. h> i n t I n p u t ; i n t I n p u t S i z e ; enum { LOAD, COMPARE, S_ALU, ALU_DIV ; i n t C o u n t e r s [ 4 ] ; s t a t i c i n t Trace = 0 ; void R e s e t C o u n t e r s ( ) { memset ( Counters, 0, s i z e o f ( C o u n t e r s ) ) ; void P r i n t C o u n t e r s A n d R e s e t ( ) { p r i n t f ( " Loads : %i Compares : %i ALU: %i DIV : %i \ n ", C o u n t e r s [LOAD], C o u n t e r s [COMPARE], C o u n t e r s [S_ALU ], C o u n t e r s [ALU_DIV ] ) ; R e s e t C o u n t e r s ( ) ; i n t MemLoad ( i n t pos ) { C o u n t e r s [LOAD] ++; f p r i n t f ( s t d e r r, "MemLoad(% i ) = %i \ n ", pos, I n p u t [ pos ] ) ; return I n p u t [ pos ] ; i n t CompareLess ( i n t val1, i n t v a l ) { C o u n t e r s [COMPARE] ++; f p r i n t f ( s t d e r r, " CompareLess(%i, %i ) \ n ", val1, v a l ) ; return v a l 1 < v a l ; i n t CompareGreater ( i n t val1, i n t v a l ) { C o u n t e r s [COMPARE] ++; f p r i n t f ( s t d e r r, " CompareGreater(%i, %i ) \ n ", val1, v a l ) ; 8

9 return v a l 1 > v a l ; i n t CompareEqual ( i n t val1, i n t v a l ) { C o u n t e r s [COMPARE] ++; f p r i n t f ( s t d e r r, " CompareEqual(%i, %i ) \ n ", val1, v a l ) ; return v a l 1 == v a l ; i n t Add ( i n t op1, i n t op ) { C o u n t e r s [S_ALU ] ++; f p r i n t f ( s t d e r r, "Add(%i, %i ) = %i \ n ", op1, op, op1 + op ) ; return op1 + op ; i n t Sub ( i n t op1, i n t op ) { C o u n t e r s [S_ALU ] ++; f p r i n t f ( s t d e r r, " Sub(%i, %i ) = %i \ n ", op1, op, op1 op ) ; return op1 op ; i n t S h i f t R i g h t ( i n t op1, i n t op ) { C o u n t e r s [S_ALU ] ++; f p r i n t f ( s t d e r r, " S h i f t R i g h t (%i, %i ) = %i \ n ", op1, op, op1 >> op ) ; return op1 >> op ; i n t Div ( i n t op1, i n t op ) { C o u n t e r s [ALU_DIV] ++; f p r i n t f ( s t d e r r, " Div(%i, %i ) = %i \ n ", op1, op, op1 / op ) ; return op1 / op ; s t a t i c i n t s e q u e n t i a l _ s e a r c h ( i n t v a l u e ) { i n t i, r e g ; f o r ( i = 0 ; i < I n p u t S i z e ; i ++) { r e g = MemLoad ( i ) ; i f ( CompareEqual ( reg, v a l u e ) ) return i ; e l s e i f ( CompareGreater ( reg, v a l u e ) ) break ; 9

10 s t a t i c i n t b i n a r y _ s e a r c h ( i n t v a l u e ) { i n t s t, end, pos, r e g ; s t = 0 ; end = I n p u t S i z e ; while ( s t <= end ) { r e g = Sub ( end, s t ) ; r e g = S h i f t R i g h t ( reg, 1 ) ; pos = Add ( s t, r e g ) ; r e g = MemLoad ( pos ) ; i f ( CompareLess ( v alue, r e g ) ) { end = Sub ( pos, 1 ) ; e l s e i f ( CompareGreater ( v alue, r e g ) ) { s t = Add ( pos, 1 ) ; e l s e { return pos ; s t a t i c i n t t r e n a r y _ s e a r c h ( i n t v a l u e ) { i n t s t, end, p o sl, posr, tmp, r e g ; p o s l = s t = 0 ; p o s r = end = I n p u t S i z e ; while ( ( end s t ) > ) { tmp = Sub ( end, s t ) ; tmp = Div ( tmp, 3 ) ; p o s l = Add ( s t, tmp ) ; tmp = Add ( tmp, tmp ) ; p o s r = Add ( s t, tmp ) ; i f ( Trace ) { f p r i n t f ( s t d e r r, " \ tposl : %i PosR : %i \ n ", p o sl, p o s r ) ; r e g = MemLoad ( p o s l ) ; i f ( CompareLess ( v alue, r e g ) ) { end = Sub ( p o sl, 1 ) ; e l s e i f ( CompareEqual ( v alue, r e g ) ) { return p o s l ; e l s e { r e g = MemLoad ( p o s r ) ; i f ( CompareLess ( v alue, r e g ) ) { s t = Add ( p o sl, 1 ) ; end = Sub ( posr, 1 ) ; e l s e i f ( CompareEqual ( v alue, r e g ) ) { return p o s r ; 10

11 e l s e { s t = Add ( posr, 1 ) ; f o r ( ; s t < end ; s t ++) { r e g = MemLoad ( s t ) ; i f ( CompareEqual ( v alue, r e g ) ) return s t ; i n t main ( i n t argc, char argv [ ] ) { FILE fp ; i n t i ; i n t s t a r t = 1, end = 1; i n t i n c r e m e n t = 1 ; i n t ( s e a r c h ) ( i n t ) = s e q u e n t i a l _ s e a r c h ; i f ( a r g c < 4 ) { f p r i n t f ( s t d e r r, " Usage :. / impl < f i l e > < s i z e > < type >" ) ; f p r i n t f ( s t d e r r, " [ < s t a r t > <end > [ < i n c r e m e n t > ] ] \ n " ) ; I n p u t S i z e = a t o i ( argv [ ] ) ; i f ( I n p u t S i z e <= 0 ) { f p r i n t f ( s t d e r r, " I n v a l i d v a l u e \ n " ) ; i f (! strcmp ( argv [ 3 ], " t " ) ) { s e a r c h = t r e n a r y _ s e a r c h ; e l s e i f (! strcmp ( argv [ 3 ], " b " ) ) { s e a r c h = b i n a r y _ s e a r c h ; i f ( a r g c > 5 ) { s t a r t = a t o i ( argv [ 4 ] ) ; i f ( s t a r t < 0 ) { f p r i n t f ( s t d e r r, " I n v a l i d s t a r t i n d e x \ n " ) ; end = a t o i ( argv [ 5 ] ) ; i f ( end < 0 ) { f p r i n t f ( s t d e r r, " I n v a l i d end i n d e x \ n " ) ; i f ( a r g c > 6 ) { i n c r e m e n t = a t o i ( argv [ 6 ] ) ; i f ( i n c r e m e n t <= 0 ) { f p r i n t f ( s t d e r r, " I n v a l i d i n c r e m e n t \ n " ) ; 11

12 I n p u t = ( i n t ) m alloc ( s i z e o f ( i n t ) I n p u t S i z e ) ; i f (! I n p u t ) { f p r i n t f ( s t d e r r, " F a i l e d t o a l l o c a t e n e c e s s a r y memory. \ n " ) ; fp = fopen ( argv [ 1 ], " r " ) ; i f (! fp ) { f p r i n t f ( s t d e r r, " F a i l e d t o open i n p u t f i l e \ n " ) ; f o r ( i = 0 ; i < I n p u t S i z e ; i ++) { i f ( f s c a n f ( fp, "%i \ n ", &I n p u t [ i ] )!= 1 ) { f p r i n t f ( s t d e r r, " F a i l e d d u r i n g r e a d. \ n " ) ; f c l o s e ( fp ) ; R e s e t C o u n t e r s ( ) ; i f ( s t a r t < 0 ) { f o r ( i = 0 ; i < I n p u t S i z e ; i ++) { ( s e a r c h ) ( I n p u t [ i ] ) ; P r i n t C o u n t e r s A n d R e s e t ( ) ; e l s e { f o r ( i = s t a r t ; i < end ; i += i n c r e m e n t ) { ( s e a r c h ) ( i ) ; P r i n t C o u n t e r s A n d R e s e t ( ) ; f r e e ( I n p u t ) ; return 0 ; A. tests.sh #! / b i n / sh rm i r f r e s u l t s mkdir r e s u l t s cd r e s u l t s SIZES=" " f o r j i n $SIZES ; do.. / impl.. / ${ j p a r e s. d a t $ j b > S e a r c h P a i r B i n $ j 1

13 .. / impl.. / ${ j p a r e s. d a t $ j t > S e a r c h P a i r T e r $ j.. / impl.. / ${ j p a r e s. d a t $ j b 1 $ j > S e a r c h W o r s t P a i r B i n $ j.. / impl.. / ${ j p a r e s. d a t $ j t 1 $ j > S e a r c h W o r s t P a i r T e r $ j.. / impl.. / ${ j p a r e s. d a t $ j b $ ( ( $ j + 1 ) ) $ ( ( $ j + 3 ) ) \ > S e a r c h S i n g l e W o r s t P a i r B i n $ j.. / impl.. / ${ j p a r e s. d a t $ j t $ ( ( $ j + 1 ) ) $ ( ( $ j + 3 ) ) \ > S e a r c h S i n g l e W o r s t P a i r T e r $ j FILES=" S e a r c h P a i r B i n S e a r c h P a i r T e r S e a r c h W o r s t P a i r B i n " FILES+=" S e a r c h W o r s t P a i r T e r S e a r c h S i n g l e W o r s t P a i r B i n " FILES+=" S e a r c h S i n g l e W o r s t P a i r T e r " f o r i i n $FILES ; do c a t $ i $ j awk { p r i n t $4 > ${ i ${ j Prep echo n " $ j " >> ${ i Mean echo " l o a d ${ i ${ j Prep ; mean ( ${ i ${ j Prep ) " \ o c t a v e \ e g r e p e " ^ ans " \ awk { p r i n t $3 >> ${ i Mean done done 13