AED 2002/2003 p.1/16. Tabelas de Dispersão. Funçoes de dispersão Encadeamento externo Procura linear Double hashing Eficiência da procura

Transcrição

1 AED 2002/2003 p.1/16 Tabelas de Dispersão Funçoes de dispersão Encadeamento externo Procura linear Double hashing Eficiência da procura

2 AED 2002/2003 p.2/16 Funções de dispersão Deve distribuir as chaves de forma uniforme e quase aleatória Deve ser rápida de calcular Diferentes funções devem ser usadas para diferentes problemas Cadeias de caracteres Inteiros Reais

3 AED 2002/2003 p.3/16 Funções de dispersão para números hash(k) = k mod M M deve ser um primo, para evitar colisões (e.g., M=256 é muito mau) Para reais Escalar para a gama [0,1.0] Multiplicar por, para obter um inteiro de Obter hash(k) = k mod M bits,

4 AED 2002/2003 p.4/16 Função de dispersão para strings Calcula uma soma ponderada dos carateres Soma é feita módulo M M deve ser um primo, para evitar colisões int hash(char *v, int M) { int h = 0, a = 127; for (; *v!= \0 ; v++) h = (a*h + *v) % M; return h;

5 AED 2002/2003 p.5/16 Função de dispersão para strings II Recalcula a base em cada iteração Evita anomalias com chaves altamente regulares int hashu(char *v, int M) { int h, a = 31415, b = 27183; for (h = 0; *v!= \0 ; v++, a = a*b % (M-1 h = (a*h + *v) % M; return h;

6 AED 2002/2003 p.6/16 Resolução por encadeamento externo Cada posição da tabela tem um ponteiro para uma lista Colisões são resolvidas juntando o elemento à cauda da lista Apagamentos são resolvidos apagando o elemento da lista Ordem de inserção: 707, 72, 14, 70, 75, 19 hash(k) = k mod 7

7 AED 2002/2003 p.7/16 Resolução por encadeamento externo static link *heads, z; static int N, M; void STinit(int max) { int i; N = 0; M = max/5; heads = malloc(m*sizeof(link)); z = NEW(NULLitem, NULL); for (i = 0; i < M; i++) heads[i] = z; Item STsearch(Key v) { return searchr(heads[hash(v, M)], v); void STinsert(Item item) { int i = hash(key(item), M); heads[i] = NEW(item, heads[i]); N++; void STdelete(Item item) { int i = hash(key(item), M); heads[i] = deleter(heads[i], item);

8 AED 2002/2003 p.8/16 Eficiência das tabelas de dispersão Resolução externa (listas ligadas) Comprimento médio das listas é N/M A probabilidade de o número de chaves em cada lista ser uma constante vezes é de onde. Se, a probabilidade de uma uma lista ter mais de 40 items é.

9 AED 2002/2003 p.9/16 Resolução por procura linear Em vez de uma lista ligada, guarda elementos na própria tabela Obriga a conhecer em avanço o número máximo de elementos: ( ) Se a posição estiver ocupada, guarda o item na posição seguinte (linear probing) ORDEM DE INSERÇAO: 70, 72, 14, 77, 19, 75 hash(k) = k mod 7

10 AED 2002/2003 p.10/16 Resolução por procura linear #include <stdlib.h> #include "Item.h" #define null(a) (key(st[a]) == key(nullitem)) static int N, M; static Item *st; void STinit(int max) { int i; N = 0; M = 2*max; st = malloc(m*sizeof(item)); for (i = 0; i < M; i++) st[i] = NULLitem; int STcount() { return N; void STinsert(Item item) { Key v = key(item); int i = hash(v, M); while (!null(i)) i = (i+1) % M; st[i] = item; N++;

11 AED 2002/2003 p.11/16 Resolução por procura linear Item STsearch(Key v) { int i = hash(v, M); while (!null(i)) if eq(v, key(st[i])) return st[i]; else i = (i+1) % M; return NULLitem;

12 AED 2002/2003 p.12/16 Remoção de Items Após achar o item, coloca-se a posição a NULL Reinserem-se todos os items que se seguem, até à próxima posição vazia void STdelete(Item item) { int j, i = hash(key(item), M); Item v; while (!null(i)) if eq(key(item), key(st[i])) break; else i = (i+1) % M; if (null(i)) return; st[i] = NULLitem; N--; for (j = i+1;!null(j); j = (j+1) % M, N--) { v = st[j]; st[j] = NULLitem; STinsert(v);

13 AED 2002/2003 p.13/16 Eficiência das tabelas de dispersão Solução por procura linear tem de ser menor que 1. Número de operações necessário para achar um item é: Hits: Misses: Número de operações cresce rapidamente quando hit miss

14 AED 2002/2003 p.14/16 Resolução por double hashing Em vez de procurar em sequência, usa uma segunda função de hashing para determinar o incremento Incremento deve ser maior que ao tamanho da tabela e primo relativamente Diminui o número de operações relativamente à procura linear

15 AED 2002/2003 p.15/16 Resolução por double hashing void STinsert(Item item) { Key v = key(item); int i = hash(v, M); int k = hashtwo(v, M); while (!null(i)) i = (i+k) % M; st[i] = item; N++; Item STsearch(Key v) { int i = hash(v, M); int k = hashtwo(v, M); while (!null(i)) if eq(v, key(st[i])) return st[i]; else i = (i+k) % M; return NULLitem;

16 AED 2002/2003 p.16/16 Eficiência das tabelas de dispersão Solução por double hashing tem de ser menor que 1. Número de operações necessário para achar um item é: Hits: Misses: "! Número de operações cresce mais lentamente quando hit miss