DICIONÁRIOS. template<class K,class T> class Par { public: K chave; T valor; Par():chave(),valor()

Transcrição

1 DICIONÁRIOS Esta estrutura inclui-se nos chamados contentores associativos, que não são mais do que uma colecção de estruturas de tipo Par, com dois membros de dados (chave de pesquisa e valor associado), que dispõe de métodos que permitem pesquisar a chave do par e devolver uma referência para o membro valor desse par, para permitir acesso directo a esse membro tendo diferentes objectivos conforme a aplicação. Um contentor associativo visto como um tipo abstracto de dados, é idêntico a um vector ou a uma lista. É outra estrutura de armazenamento de informação com operações para aceder e modificar elementos. A principal diferença é que as operações num contentor associativo usam uma chave em vez de um índice ou de um algoritmo de pesquisa para aceder ao elemento. Um programador pode usar a chave sem se preocupar como os elementos estão fisicamente guardados nem como as operações fazem a associação entre chave e elemento. No caso em que a chave é uma palavra e o membro valor é um texto que descreve o significado da chave, então o contentor designa-se por dicionário. Neste caso podemos usufruir da vantagem de fazer uma sobrecarga do operador de indexação [ ], em que o operador toma a chave como argumento e devolve uma referência para o membro valor do par. Tal como um índice de um array, o operador pode ser usado em ambos os lados da instrução de atribuição. Assim, sendo dic o meu objecto dicionário, posso inserir o par na estrutura contentora fazendo: dic["ceu"]="sky"; ou acedendo ao valor (significado) pela chave: cout<<dic["ceu"]<<endl; Como exemplo de aplicação de dicionários podemos citar as tabelas de símbolos nos compiladores (dicionários com chaves duplicadas). Neste caso, a chave é o identificador e o valor será uma estrutura contendo o tipo(int, float,...), endereço de memória, valor,... Vejamos agora como podemos definir em C++, uma estrutura dicionário, simplificada, que permita realizar o que acabamos de indicar. Seguidamente, serão estudados contentores associativos baseados em tabelas de hash. class Par public: K chave; T valor; Par():chave(),valor() Instituto Superior de Engenharia do Porto 1

2 ; ; class Dicionario private: Par<K,T> *array; int max; int ocup; public: Dicionario(int dim); ~Dicionario(); T& operator[](const K & ch); void escreve_tudo(); ; Dicionario<K,T>::Dicionario(int dim) max=(dim<16?16:dim); ocup=0; array=new Par<K,T>[max]; Dicionario<K,T>::~Dicionario() delete[] array; T & Dicionario<K,T>::operator [](const K & ch) int enc=0; Par<K,T> *pp; for(pp=array;pp!=(array+ocup);++pp) if(ch==pp->chave) enc=1; return pp->valor; if(ocup==max) overflow-duplicar espaço Par<K,T> *nvec=new Par<K,T>[max*2]; Instituto Superior de Engenharia do Porto 2

3 for(int i=0;i<max;++i) nvec[i]=array[i]; delete [] array; array=nvec; max=max*2; pp=& array[ocup++]; pp->chave=ch; return pp->valor; void Dicionario<K,T>::escreve_tudo() for(int i=0;i<ocup;++i) cout<<array[i].chave<<" : "<<array[i].valor<<endl; TABELAS DE HASH Consideremos o caso ideal: um elemento elem, tem a chave k e existe uma função f (função de hash), esta função vai mapear o elemento elem (chave k ) na posição da tabela, f(k), onde se deve encontrar o elemento elem com chave k. Exemplo: suponhamos uma escola em que os números dos alunos variam entre e A função f deverá ser tal que fará um mapeamento entre o número do aluno e a posição na tabela e poderá ser esta: f(k)=k Assim o aluno n (k=991346), ocupará a posição (posição=f(k) ),346 (=k ) da tabela. De uma forma geral a tabela é inicializada a 0 e a inicialização será de ordem n, (n é o número de elementos possíveis da tabela) e a pesquisa de ordem 1, assim como o juntar elemento e o eliminar. Acontece a maioria das vezes que o número de elementos possíveis para incluir na tabela é muito superior ao tamanho da tabela e neste caso é possível que a mesma função aplicada a chaves diferentes dê como resultado o mesmo valor de índice da tabela. Cada posição na tabela de hash designa-se por bucket. Cada bucket pode conter um ou mais elementos. Instituto Superior de Engenharia do Porto 3

4 No caso de a aplicação da função de hash a duas chaves distintas, do mesmo universo resultar na mesma posição e se o bucket estiver completo diremos que houve colisão. Para simplificar consideramos que cada bucket contem um elemento. As funções de hash terão que ser definidas criteriosamente. Uma função standard, para o caso de chaves inteiras será fazer o resto da divisão inteira da chave pelo tamanho da tabela. Claro que isto será uma opção razoável se a chave não tiver propriedades indesejáveis, como o exemplo que apontamos a seguir: Exemplo: suponhamos uma tabela com 10 posições, e a função de hash a standard. Se todas as chaves terminassem em 0, então seria muito má escolha esta função uma vez que todos os valores colidiriam na posição 0. Também o tamanho da tabela não estaria bem definido. É aceitável que o tamanho da tabela seja um número primo. Quando a entrada são valores aleatórios inteiros, então a função standard é muito simples e distribui as chaves igualmente. Se a chave for uma string ( podemos usar a seguinte função de hash int hash (const String &chave, const int tamanho) char *ptr=chave; int valor=0; while( *ptr) valor = valor + (*ptr ++); return (valor % tamanho); Esta função é fácil de implementar, mas se a tabela é grande não distribui bem as chaves. Suponhamos que o tamanho da tabela é (número primo) e que as chaves contêm 8 ou menos caracteres. Como um caracter é um inteiro entre 0 e 127 a função só assume valores entre 0 e 1016 (127*8). Isto é evidentemente, uma distribuição pouco equitativa. Outra possível função seria: int hash (const String &chave, const int tamanho) return (chave[o] + 26*chave[1] + 676*chave[2]) % tamanho; Assume-se que a chave tem pelo menos comprimento será o nº de letras Instituto Superior de Engenharia do Porto 4

5 do alfabeto e 676 será Esta função só examina os primeiros 3 caracteres e se o tamanho da tabela for como o indicado anteriormente,10007, então pode esperar-se uma distribuição razoavelmente equitativa. Mas, infelizmente as linguagens não são aleatórias, embora haja 26 3 = combinações possíveis de 3 caracteres só se verificam 2851 combinações. Mesmo que essas não colidam só 28% da tabela será usada. Portanto esta função também não será apropriada se a tabela for muito grande. Podemos ainda usar outra função: int hash (const String &chave, const int tamanho) char *ptr=chave; int valor=0; while( *ptr) valor = valor <<5 + (*ptr ++); valor<<5 equivale a multiplicar por 32 return (valor % tamanho); Usou-se o valor 32, para se poder fazer um shift de bits. Esta função é rápida, excepto se as chaves forem muito grandes. É prática corrente não usar todos os caracteres da chave, mas usar só alguns, por exemplo os das posições ímpares MÉTODOS PARA RESOLUÇÃO DE COLISÕES 1. Encadeamento Externo Quando ocorre uma colisão, os elementos que colidiram são colocados numa lista ligada. No exemplo abaixo esquematizado, a tabela de hash está organizada de forma a que cada bucket contem um apontador para um nó (cabeça da lista de colisões) Instituto Superior de Engenharia do Porto 5

6 Tabela[ ] A tabela representada tem 11 posições, e a função de hash escolhida é a função da divisão, que é a mais vulgar. Estamos a supor que a chave é um valor inteiro. A função toma o seguinte aspecto: f(k) = k % D, em que o índice da tabela é dado pelo resto da divisão inteira da chave pelo tamanho, D, da tabela. As posições na tabela são portanto numeradas de 0 a D- 1. Há muitas vezes necessidade de pré processar a chave antes de lhe aplicar a função de hash. Assim para aplicação da função divisão há que converter a chave num número inteiro. Os algoritmos de pesquisa, juntar elemento e eliminar elemento traduzem-se nos correspondentes algoritmos em lista ordenada. A cabeça é dada pelo valor do apontador na posição da tabela dada por h(k). Poder-se-ia melhorar a performance das lista se considerássemos por exemplo, além do apontador cabeça um apontador para a cauda da lista, verificando-se no inicio das operações se o elemento que colidiu é o que apresenta a maior chave. Outra forma de melhorar a performance seria considerar, em vez de lista ordenada, uma estrutura de árvore binária de pesquisa, mas isto deixamos para exercício. 2. Endereçamento Linear Aberto Este método também se usa quando o tamanho da tabela é menor do que a gama de valores possíveis resultantes da aplicação da função de hash e que por consequência surgem colisões. Assim sempre que se verifica uma colisão, não é possível colocar o elemento na posição fornecida pela função de hash uma vez que o bucket correspondente está cheio, recorre-se a este método, obrigando a colocar o elemento no próximo bucket vazio. Desta forma a pesquisa para o próximo bucket disponível é feita considerando a tabela como se fosse circular. A pesquisa inicia-se no bucket dado pela função de hash e um dos 3 casos pode acontecer: Instituto Superior de Engenharia do Porto 6

7 Encontramos um bucket com a chave que procurávamos (encontramos o elemento a pesquisar, pesquisa com sucesso) Encontramos um bucket vazio (pesquisa sem sucesso, o elemento não existe) Regressamos ao bucket inicial (pesquisa sem sucesso e a tabela está cheia). Vamos supor que tínhamos os mesmos valores usados na exemplificação do encadeamento externo e cuja entrada era dada pela ordem seguinte: 11, 58, 38, 60, 93, 22, 44, 16, A posição para a chave 11 tem índice 0. Quando colocar o valor 22, que também deveria ocupar a posição 0 esta já estará ocupada. Teremos então que percorrer a lista fazendo: posição =( posição + 1 )% D até encontrar uma posição vazia, que felizmente neste caso será a próxima. O valor de D neste exemplo tem o valor 11. Seguidamente descreveremos o correspondente algoritmo para pesquisar e inserir o valor de chave x. Consideramos que a nossa tabela terá um campo conteúdo e um campo designado por ocupação que será verdadeiro ou falso conforme a tabela tem esse índice ocupado ou não. Pesquisar_Inserir(x) Inicio Pesquisar j = h(x) inicial = j enc = 0 Repete Se (tabel[j].ocupaçao=verdade e tabela[j].conteudo=x) Então enc=1 Senão j=(j+1)% D Até (enc=1 ou j=inicial ou tabela[j].ocupaçao=falso) Inserir Se (enc=0) Instituto Superior de Engenharia do Porto 7

8 Fim Então Se (j=inicial) Então Overflow Senão tabela[j].conteudo=x tabela[j]. Ocupaçao=verdade Senão O elemento já existe Seguidamente analisaremos um algoritmo para eliminarmos um elemento x da tabela, embora esta estrutura deva ser utilizada em aplicações em que predominam inserções e pesquisas. Para eliminarmos um elemento x da tabela, começaremos por fazer uma pesquisa e caso esse valor seja encontrado, suponhamos que existia no índice j, então colocaríamos o campo ocupação da tabela nessa posição a falso e teríamos que verificar se o elemento seguinte (posição i) estava fora da posição dada pela função de hash (posição r), isto é se r não estivesse entre j e i, teria que ocupar o lugar de j e agora j tomaria o valor de i e tudo se repetiria, até encontrar-se uma posição vazia. Caso contrário, o elemento da posição i estava na posição correcta, então avançar-se-ia para o próximo i até encontrar uma posição livre ou um valor fora da posição devida. Um algoritmo possível será o seguinte: Algoritmo Inicio Pesquisa, considera-se que encontrou na posição j Se (enc==1) Então Repete tabela[j]. ocupaçao=falso i=(j+1)%d Repete Se (tabela[i]. ocupa çao==verdade) Então r=h (tabela[i]. conteudo) Se (((r>j) e (r< =i)) ou ((r>j) e (i<j)) ou ((r<=j) e (i<j))) Então r_entreji=1 Senão r_entreji=0 Até (tabela [i].ocupaçao ==falso ou r_entreji=0) Se (r_entreji=0 e tabela[i].ocupaçao=verdade) Então tabela[j].conteudo=tabela[i]. conteudo tabela[j]. ocupaçao=verdade Instituto Superior de Engenharia do Porto 8

9 Fim j=i Até (tabela[i]. ocupaçao ==falso) Senão Elemento não existe Para verificar se r se encontra entre a posição j e a posição i três situações serão possíveis: j r i i j r r i j Comparação de métodos de pesquisa Já vimos quatro métodos de pesquisa, pesquisa sequencial, pesquisa binária, pesquisa em árvore binária e hashing. A ordem de complexidade temporal destes métodos é normalmente determinada através do número médio de comparações necessárias para localizar um elemento na estrutura. Vimos que na pesquisa sequencial era de O(n) e na pesquisa binária e árvore binária de pesquisa era de O( log 2 n). A análise no caso de hashing é um pouco mais complicada, uma vez que depende da qualidade da função de hash e do tamanho da tabela. Uma boa função de hash, fornece uma distribuição uniforme dos valores de hash e quando combinado com uma tabela relativamente grande, o número de colisões é reduzido. Numa tabela de hash podemos definir o factor de ocupação (? ) como sendo o número de elementos inseridos na tabela (m) sobre o tamanho da tabela (n),? = m n. Instituto Superior de Engenharia do Porto 9

10 Quando a tabela está vazia? = 0. À medida que se inserem elementos na tabela,? vai aumentando, e maior é a probabilidade de colisão. No caso de endereçamento aberto, o seu valor máximo será 1 quando estiver completamente preenchida (m=n). No caso de encadeamento externo, como as listas de colisão podem crescer tanto quanto o que precisamos,? pode ser maior do que 1. A análise formal da complexidade do hashing está fora do âmbito desta disciplina mas podemos apresentar os resultados obtidos por Knuth neste campo. Assim, chegou às fórmulas abaixo indicadas, para determinação do número médio de acessos necessários para uma pesquisa com sucesso e sem sucesso no caso de encadeamento externo e no caso de endereçamento aberto. Resolução de Colisões Pesquisa com Sucesso Pesquisa sem Sucesso Endereçamento [1 2(1-?)] +?2 [1 2(1-?) 2 ] +? 2 Encadeamento 1 +?2 e -? +? Esta tabela mostra que o endereçamento aberto é bom desde que o factor de ocupação se mantenha baixo (< 75%). De uma forma geral o encadeamento é um método melhor. Se?=1 o encadeamento exige 1.5 acessos para uma pesquisa com sucesso, mas o método por endereçamento requer, com a tabela cheia M72 acessos. Sem dúvida, o hashing é um processo de pesquisa extremamente rápido, contudo cada um dos métodos tem a sua utilização. A pesquisa sequencial é eficiente quando o número de elementos é pequeno e os dados não tem que estar ordenados. A pesquisa binária é mais rápida mas exige que os dados estejam ordenados em array. Este tipo de pesquisa não é viável em situações em que os dados são adquiridos em tempo de execução( como tabelas de símbolos), uma vez que um array ordenado é um veículo ineficiente para inserções e eliminações. Por estas razões hashing e árvore binária de pesquisa competem,a árvore binária de pesquisa não é tão rápida mas tem o aspecto interessante de fornecer dados ordenados através de uma visita simétrica. Hasihng é o melhor método quando se pretende acesso rápido e não é requerido informação ordenada. Instituto Superior de Engenharia do Porto 10

11 Aplicações Aplicações desta estrutura são muitas, nomeadamente em compiladores, onde são usadas para manter o controlo das variáveis declaradas no código fonte, são conhecidas por tabelas de símbolos. São realmente as aplicações ideais para esta estrutura, uma vez que as operações realizadas são as inserções e pesquisas. Os identificadores de variáveis são geralmente pequenos e portanto são de computação rápida. Outra aplicação vulgar é nos programas de jogos. Á medida que o programa procura através de diferentes linhas de jogada, conserva o registo de cada posição ocorrida, calculando uma função de hash baseada nessa posição e "guardando" o movimento para essa posição. Se a mesma posição volta a ocorrer, geralmente por uma simples transposição de movimentos, o programa pode evitar cálculos dispendiosos. Esta acção genérica, feita em programas de jogos, é conhecida como "tabela de transposição". Ainda outra aplicação é na detecção de erros de ortografia. É feito hash a um diccionário completo e as palavras pode ser verificadas em tempo constante. As tabelas de hash são também indicadas para isto, uma vez que não é preciso corrigir as palavras, mas simplesmente indicar que não estão correctamente escritas. Instituto Superior de Engenharia do Porto 11