Strukture podataka i algoritmi

Gordan Kreigordan.kresic@vsite.hr

Hash tablica

imamo n kljueva iz skupa U, |U|=M i polje od m elemenata

uvodimo hash funkciju h:U -> [1..m]

svodimo veliki skup (M moguih) na m pretinaca

rezultat funkcije je indeks u polju

vie kljueva zavri u istom pretincu sudar (collision):

dobra hash funkcija minimizira sudare

nuna obrada sudara

za popunjenost pretinaca do 70% vjerojatnost sudara je malena

u idealnom sluaju (nema sudara) ubacivanje i pretraga O(1)

iteracija daje nasumine rezultate

Hash funkcije

cilj: rasporeivati elemente to sluajnije i to uniformnije

h(x) = x mod m, za prosti m nepogodno ako ne moemo prilagoditi veliinu tablice na prosti broj

h(x) = ((ax + b) mod p) mod m, a, b sluajni, a, b < p, a 0 u prosjeku vrlo dobra za sve ulaze

enkripcija: Merkle-Damgrdov princip (MD5, SHA1 i SHA2), kolizije gotovo

nevjerojatne

specijalizirane hash funkcije: gotovo uvijek najbolji rezultati, ali samo za jedan skup

Hash funkcije, obrada sudara

Ulanavanje (chaining):

pretinci su vezane liste

pretraivanje: sekvencijalni prolaz kroz listu

ubacivanje: test na duplikate

dinamika alokacija, dodatna memorija za pokazivae

radi za bilo koji broj kljueva

Hash funkcije, obrada sudara

Otvoreno adresiranje (open addressing):

koristimo samo primarnu tablicu

veliina tablice fiksna

kod sudara na neki nain traimo alternativnu poziciju (re-hashing)

za gotovo pune tablice (>80%) operacije postaju O(n)

Hash funkcije, obrada sudara

Otvoreno adresiranje (re-hashing) obrada sudara:

linear probing:

sekvencijalni prolazak kroz tablicu u fiksnim koracima (step) dok se ne

pronae prvo slobodno mjesto ili se proe cijela tablica:

H(x,i) = (H(x) + step * i) % n

lako dolazi do sekundarnih sudara

stvaranje grozdova (clustering)

dobre cache performanse

quadratic probing:

sekvencijalni prolazak kroz tablicu sa koracima koji rastu eksponencijalno:

H(x,i) = (H(x) + step * i2) % n

double hashing:

sekvencijalni prolazak kroz tablicu uzastopnom primjenom druge, neovisne

hash funkcije:

H(x,i) = (h1(x) + i * h

2(x)) % n

Hash funkcije, obrada sudara

Preljevanje:

dvije tablice - primarna i preljevna - fiksnih veliina

stvaramo veze iz primarne u preljevnu

slino ulanavanju, no kako je memorija za priljeve unaprijed alocirana,

performanse su bolje

Hash funkcije, pregled

Prednosti Mane

Ulanavanje neogranien broj elemenataneogranien broj sudara

veliki gubici za relativno prazne tablice

Otvoreno

adresiranje

brzo re-hashiranjebrz pristup (primarna tablica)

unaprijed zadan maksimalni broj elemenataviestruki sudari brisanje

Preljevanje brz pristupsudari ne zapunjavaju primarnu tablicu

tea procjena veliine primarne i preljevne tablice

9ATP: Skup (set)

apstrakcija skupa - neureena kolekcija podataka

nema duplikata

efikasno dodavanje, brisanje, te provjera postojanja konkretnog lana

10

Skup, suelje

Tipovi:

typedef char set_element_t;

typedef struct set_tag *set_t;

typedef struct set_iterator_tag *set_iterator_t;

Operacije:

set_t set_new(); /* stvara novi (prazni) skup */

set_t set_new_advanced(

int (*compare)(const set_element_t, const set_element_t),

size_t (*hash)(const set_element_t)

); /* stvara novi (prazni) skup, elementi se usporedjuju funkcijom compare,

a hash racuna funkcijom hash */

void set_delete(set_t s); /* unitava skup */

int set_is_empty(set_t set); /* vraca 1 ako je skup prazan, a 0 inace */

int set_size(set_t set); /* vraca broj elemenata u skupu */

void set_add(set_t s, set_element_t e); /* dodaje element u skup */

void set_remove(set_t s, set_element_t e); /* uklanja element iz skupa */

int set_is_member(set_t s, set_element_t e); /* vraa 1 ako je skup sadri dani element,

a 0 inae */

11

Operacije (nastavak):

int set_is_subset(set_t s1, set_t s2); /* vraa 1 ako je skup s1 podskup skupa s2, a

0 inae */

set_t set_union(set_t s1, set_t s2); /* vraa uniju skupova s1 i s2 */

set_t set_intersection(set_t s1, set_t s2); /* vraa presjek skupova s1 i s2 */

set_t set_difference(set_t s1, set_t s2); /* vraa razliku skupova

s1 i s2 */

12

Operacije (nastavak):

set_iterator_t set_iterator(set_t s); /* vraa iterator na prvi element skupa */

set_element_t set_iget(set_iterator_t iter); /* vraa element na danoj poziciji */

set_element_t set_iremove(set_iterator_t iter); /* uklanja element sa zadane

pozicije */

void set_iterator_next(set_iterator_t iter); /* postavlja iterator na sljedeu

poziciju u skupu */

int set_iterator_is_valid(set_iterator_t iter); /* vraca 1 ukoliko iterator

pokazuje na ispravnu poziciju u skupu, a 0 inae */

int set_iterator_is_equal(set_iterator_t iter1, set_iterator_t iter2); /* vraa 1

ukoliko oba iteratora pokazuju na istu poziciju u skupu, a 0 inae */

void set_iterator_set(set_iterator_t iter1, set_iterator_t iter2); /* postavlja

iterator iter1 na istu poziciju kao i iter2 */

void set_iterator_delete(set_iterator_t iter); /* unitava iterator */

13

Skup, implementacije

pomou sortirane vezane liste:

sortirani skup

ubacivanje novog lana: O(n)

izbacivanje lana: O(n)

provjera lana: O(n)

pomou binarnog stabla:

sortirani skup

veina operacija: O(log n)

pomou hash tablice:

veina operacija: prosjeno O(1), u najgorem sluaju O(n)

pomou bit-vektora:

skup od n prirodnih brojeva moe efikasno biti implementiran kao n-bitni vektor:

0 1 2 3 4 5 6 7 8 91 0 0 1 1 0 1 0 0 0

14

Dokumentacija:

http://en.wikipedia.org/wiki/Hash_function

http://en.wikipedia.org/wiki/Hash_table

http://en.wikipedia.org/wiki/Pigeonhole_principle

http://en.wikipedia.org/wiki/Birthday_problem

http://en.wikibooks.org/wiki/Data_Structures/Hash_Tables

http://en.wikipedia.org/wiki/Set_(computer_science)

Slide 1Slide 2Slide 3Slide 4Slide 5Slide 6Slide 7Slide 8Slide 9Slide 10Slide 11Slide 12Slide 13Slide 14