Adatszerkezetek Hasító táblák. Dr. Iványi Péter

Hasonló dokumentumok
Adatszerkezetek 2. Dr. Iványi Péter

Programozás alapjai II. (7. ea) C++ Speciális adatszerkezetek. Tömbök. Kiegészítő anyag: speciális adatszerkezetek

Speciális adatszerkezetek. Programozás alapjai II. (8. ea) C++ Tömbök. Tömbök/2. N dimenziós tömb. Nagyméretű ritka tömbök

Programozás alapjai II. (7. ea) C++

Táblázatok fontosabb műveletei 1

Algoritmusok és adatszerkezetek gyakorlat 06 Adatszerkezetek

Adatszerkezetek 7a. Dr. IványiPéter

9. előadás. A táblázat. A táblázatról általában, soros, önátrendező, rendezett és kulcstranszformációs táblázat

Ugrólisták. RSL Insert Example. insert(22) with 3 flips. Runtime?

Algoritmusok és adatszerkezetek 2.

Önszervező bináris keresőfák

Adatszerkezetek I. 7. előadás. (Horváth Gyula anyagai felhasználásával)

Tuesday, March 6, 12. Hasító táblázatok

Adatszerkezetek Adatszerkezet fogalma. Az értékhalmaz struktúrája

Programozás II. előadás

Tartalom Keresés és rendezés. Vektoralgoritmusok. 1. fejezet. Keresés adatvektorban. A programozás alapjai I.

Rendezések. Összehasonlító rendezések

A félév során előkerülő témakörök

Haladó rendezések. PPT 2007/2008 tavasz.

Keresés és rendezés. A programozás alapjai I. Hálózati Rendszerek és Szolgáltatások Tanszék Farkas Balázs, Fiala Péter, Vitéz András, Zsóka Zoltán

Egyirányban láncolt lista

Láncolt listák. Egyszerű, rendezett és speciális láncolt listák. Programozás II. előadás. Szénási Sándor

Algoritmusok és adatszerkezetek gyakorlat 07

Adatszerkezetek 1. Dr. Iványi Péter

Algoritmizálás. Horváth Gyula Szegedi Tudományegyetem Természettudományi és Informatikai Kar

Adatszerkezetek Tömb, sor, verem. Dr. Iványi Péter

Adatszerkezetek 1. előadás

Programozás I. 1. előadás: Algoritmusok alapjai. Sergyán Szabolcs

Adatszerkezetek 2. Dr. Iványi Péter

Mutatók és címek (ism.) Programozás alapjai C nyelv 8. gyakorlat. Indirekció (ism) Néhány dolog érthetőbb (ism.) Változók a memóriában

Algoritmuselmélet. Hashelés. Katona Gyula Y. Számítástudományi és Információelméleti Tanszék Budapesti Műszaki és Gazdaságtudományi Egyetem

Struktúra nélküli adatszerkezetek

Algoritmuselmélet. Hashelés. Katona Gyula Y. Számítástudományi és Információelméleti Tanszék Budapesti Műszaki és Gazdaságtudományi Egyetem

Programozás alapjai C nyelv 8. gyakorlat. Mutatók és címek (ism.) Indirekció (ism)

Amortizációs költségelemzés

Módosítható Prioritási sor Binomiális kupaccal. Wednesday, March 21, 12

Kupac adatszerkezet. A[i] bal fia A[2i] A[i] jobb fia A[2i + 1]

A programozás alapjai előadás. Amiről szólesz: A tárgy címe: A programozás alapjai

Felvételi vizsga mintatételsor Informatika írásbeli vizsga

Algoritmuselmélet 2. előadás

Algoritmusok és adatszerkezetek I. 1. előadás

A programozás alapjai előadás. [<struktúra változó azonosítók>] ; Dinamikus adatszerkezetek:

Gelle Kitti Algoritmusok és adatszerkezetek gyakorlat - 07 Hasítótáblák

Programozás alapjai gyakorlat. 4. gyakorlat Konstansok, tömbök, stringek

Algoritmusok és adatszerkezetek I. 5. előadás

Ellenőrző kérdések. 36. Ha t szintű indexet használunk, mennyi a keresési költség blokkműveletek számában mérve? (1 pont) log 2 (B(I (t) )) + t

Generikus osztályok, gyűjtemények és algoritmusok

Adatszerkezet - műveletek

2018, Diszkrét matematika

Számláló rendezés. Példa

Tartalomjegyzék. Köszönetnyilvánítás. 1. Az alapok 1

Programozási technológia

Programozás alapjai 9. előadás. Wagner György Általános Informatikai Tanszék

Rendezések. A rendezési probléma: Bemenet: Kimenet: n számot tartalmazó (a 1,a 2,,a n ) sorozat

HÁZI FELADAT PROGRAMOZÁS I. évf. Fizikus BSc. 2009/2010. I. félév

Hasító táblázatok. Hasító függvények, kulcsütközés kezelése. Programozás II. előadás. Szénási Sándor

file:///d:/okt/ad/jegyzet/ad1/b+fa.html

end function Az A vektorban elõforduló legnagyobb és legkisebb értékek indexeinek különbségét.. (1.5 pont) Ha üres a vektor, akkor 0-t..

Programozási segédlet

Adatszerkezetek. Nevezetes algoritmusok (Keresések, rendezések)

Alkalmazott modul: Programozás. Programozási tételek, rendezések. Programozási tételek Algoritmusok és programozási tételek

Programozás I. Egyszerű programozási tételek. Sergyán Szabolcs

Érdekes informatika feladatok

Adatszerkezetek és algoritmusok

B-fa. Felépítés, alapvető műveletek. Programozás II. előadás. Szénási Sándor.

Adatszerkezetek I. 8. előadás. (Horváth Gyula anyagai felhasználásával)

10. előadás Speciális többágú fák

Adatszerkezetek I. 6. előadás

Rendezettminta-fa [2] [2]

15. tétel. Adatszerkezetek és algoritmusok vizsga Frissült: január 30.

Programozás I. Egyszerű programozási tételek. Sergyán Szabolcs

Információk. Ismétlés II. Ismétlés. Ismétlés III. A PROGRAMOZÁS ALAPJAI 2. Készítette: Vénné Meskó Katalin. Algoritmus. Algoritmus ábrázolása

1. ábra. Egy rekurzív preorder bejárás. Egy másik rekurzív preorder bejárás

Adatbázis-kezelő rendszerek. dr. Siki Zoltán

Adatbáziskezelés. Indexek, normalizálás NZS 1

Dr. Schuster György február / 32

Információs Technológia

Gyakorló feladatok az 1. nagy zárthelyire

A verem (stack) A verem egy olyan struktúra, aminek a tetejéről kivehetünk egy (vagy sorban több) elemet. A verem felhasználása

Sapientia Egyetem, Matematika-Informatika Tanszék.

A számítástudomány alapjai. Katona Gyula Y. Számítástudományi és Információelméleti Tanszék Budapesti Műszaki és Gazdaságtudományi Egyetem

Bánsághi Anna 2014 Bánsághi Anna 1 of 68

RSA algoritmus. P(M) = M e mod n. S(C) = C d mod n. A helyesség igazoláshoz szükséges számelméleti háttér. a φ(n) = 1 mod n, a (a 1,a 2,...

.Net adatstruktúrák. Készítette: Major Péter

Adatbázis rendszerek. dr. Siki Zoltán

BBTE Matek-Infó verseny mintatételsor Informatika írásbeli vizsga

Egyszerű programozási tételek

Függvények. Programozás alapjai C nyelv 7. gyakorlat. LNKO függvény. Függvények(2) LNKO függvény (2) LNKO függvény (3)

Programozás I. Matematikai lehetőségek Műveletek tömbökkel Egyszerű programozási tételek & gyakorlás V 1.0 OE-NIK,

Programozás alapjai C nyelv 7. gyakorlat. Függvények. Függvények(2)

22. GRÁFOK ÁBRÁZOLÁSA

Bevezetés a programozásba. 5. Előadás: Tömbök

Láncolt Listák. Adat1 Adat2 Adat3 ø. Adat1 Adat2 ø Adat3

Számítógépes Hálózatok. 7. gyakorlat

Információs Technológia

Programozás I. zárthelyi dolgozat

Edényrendezés. Futási idő: Tegyük fel, hogy m = n, ekkor: legjobb eset Θ(n), legrosszabb eset Θ(n 2 ), átlagos eset Θ(n).

Algoritmusok vektorokkal keresések 1

5. SOR. Üres: S Sorba: S E S Sorból: S S E Első: S E

Programozási technikák Pál László. Sapientia EMTE, Csíkszereda, 2009/2010

Átírás:

Adatszerkezetek Hasító táblák Dr. Iványi Péter 1

Hash tábla A bináris fáknál O(log n) a legjobb eset a keresésre. Ha valamilyen közvetlen címzést használunk, akkor akár O(1) is elérhető. A hash tábla a tömb általánosításaként is felfogható, ahol az index bármilyen érték lehet. Ugyanakkor több lehetséges kulcs van mint hely a táblában 2

Hash tábla Nagy adathalmaz, de sok kihagyás van az adatok között Hash függvény Kis adathalmaz 3

Hash tábla Tömbnél az index: egész szám Hash tábla: valós szám, szöveg, egy másik tömb vagy bármi egyéb... Az index: a kulcs A hash táblába tárolt adat: az érték 4

Primitív hash tábla, tömb n elemű tömbben akarjuk tárolni a megadott adatokat Feltételezzük, hogy a kulcs csak egész szám Maradék osztást használunk insert(index, ertek) { tomb[index mod n] = ertek; } 5

Hash tábla Trükk: a kulcsból tömb indexet hozunk létre Például, ha adva van egy név, akkor szeretnénk megtudni a hozzátartozó telefonszámot 6

Hash függvény A hash táblák alapja a megfelelően megválasztott hash függvény. Irodalom tartalmaz jót és rosszat is Nincs univerzális megegyezés arról mi tekinthető jónak Rosszul választott függvény kulcs ütközéshez (collision) vezet Kulcsok csoportosulása (clustering): Ebben az esetben annak a valószínűsége hogy több kulcs ugyanazt az indexet adja meg jóval nagyobb mintha egy véletlen szám generátor függvényt használtunk volna. 7

Függvény minősége: Hash függvény Egyszerűség (forrás kódban a sorok száma) Sebesség (időmérés, benchmark) Erő mérése: Statisztikai tesztek melyek megállapítják, hogy a hash függvény mennyiben különbözik a véletlen szám generáló függvénytől Talán a legfontosabb mérési módszer a hash függvény jóságának a mérésére, hogy a függvényre jellemző-e az Avalanche effektus 8

Avalanche effektus Ha a bemenetet kicsit megváltoztatjuk (például csak egy bitet átállítunk) akkor a kimenet jelentősen megváltozik (például az eredménynek több mint a fele megváltozik) 9

Hash függvény A hash függvény akkor jó, ha: amikor a bemenet egy bitje megváltozik, akkor a kimenet minden bitje legalább 50 %-os valószínűséggel változik meg 10

Ütközések feloldása Ha két kulcs ugyanazt az indexet adja, akkor nem lehet két rekordot ugyanaz a helyen tárolni. Ebben az esetben egy másik helyet (indexet) kell találni. Feloldás túlcsordulás kezeléssel Láncolás (chaining) Alternatív címzés (open addressing) 11

Túlcsordulás kezelés tabla[n]; overflow[max_overflow]; end_index = 0; Insert(kulcs, ertek) { h = hash(kulcs) mod n; if(tabla[h]!= ures) { if(end_index == MAX_OVERFLOW) tabla betelt; overflow[end] = kulcs és ertek; end = end + 1; } else tabla[h] = kulcs és ertek; } 12

Többféle probléma Túlcsordulás kezelés A túlcsordulás tömböt is végig kell keresni, Ha nagy a túlcsordulás tömb lassítja a keresést, törlést, beillesztést, O(n) lesz ismét 13

Láncolás A hash táblában minden rekord valójában egy láncolt lista Keresés, törlés kiegészül azzal, hogy a listán végig kell menni 14

Láncolás Elvileg szükség lehet rendezett listára, hogy gyorsabban kereshessünk, DE Ha jó a hash függvény akkor a listák rövidek és nincs szükség a rendezésre, mert a keresés a rendezetlen listában így is nagyon rövid lesz! 15

Alternatív címzés Alternatív címet keresünk ütközés esetén Lineáris próba Quadratikus próba Dupla hashing 16

Példa: Lineáris próba A hash tábla legyen egy 11 elemű tömb insert(kulcs, ertek) 0 1 2 3 4 5 6 7 8 9 10 { h = hash(kulcs) mod n; while(tabla[h]!= ures) { h = (h + 1) mod n; } tabla[h] = kulcs és ertek; } 17

Lineáris próba 0 1 2 3 4 5 6 7 8 9 10 Beillesztés: 426 426 mod 11 = 8 426 0 1 2 3 4 5 6 7 8 9 10 Beillesztés: 921 921 mod 11 = 8 426 921 0 1 2 3 4 5 6 7 8 9 10 Beillesztés: 715 715 mod 11 = 0 715 426 921 18

Lineáris próba 0 1 2 3 4 5 6 7 8 9 10 Beillesztés: 129 129 mod 11 = 8 426 715 921 129 0 1 2 3 4 5 6 7 8 9 10 Beillesztés: 514 514 mod 11 = 8 514 426 921 715 129 0 1 2 3 4 5 6 7 8 9 10 Beillesztés: 287 287 mod 11 = 1 715 514 287 426 921 129 19

Lineáris próba Jellemző rá a csoportosulás (clustering) Előző példában a 8-az index esetén egyre nehezebb adatot beilleszteni. Csökkenti az algoritmus sebességét Lehetőleg csak félig legyen tele a hash tábla 20

Lineáris próba A lépésköz általában 1, bár lehet mást is használni Működés feltételei: A hash tábla mérete vagy prím szám legyen vagy kettő hatványa Ha a tábla mérete kettő hatványa akkor a lépésköz csak páratlan lehet 21

Lineáris próba, törlés A törlés problematikusabb Ha valóban törlünk hibás működést kapnánk Ha csak törlünk egy elemet, akkor a következő beillesztésnél a lináris próba idő előtt leállhat 22

Lineáris próba, törlés A törlés problematikusabb Ha valóban törlünk hibás működést kapnánk Példa megoldás, de a beillesztést is módosítani kell remove(kulcs) { } h = hash(kulcs) mod n; while(tabla[h]!= ures) { } h = (h + 1) mod n; tabla[h] = DELETED; insert(kulcs, ertek) { h = hash(kulcs) mod n; while( { } tabla[h]!= ures && tabla[h]!= DELETED) h = (h + 1) mod n; tabla[h] = kulcs és ertek; } 23

Quadratikus próba Nem konstans lépést használunk. insert(kulcs, ertek) { h = hash(kulcs) mod n; for(step = 1; tabla[h]!= ures; step++) { h = (h + step * step) mod n; } tabla[h] = kulcs és ertek; } 24

Quadratikus próba Nem jön létre csoportosulás Csak akkor garantált a működés ha: A tábla maximum félig telik meg (félig üres) A tábla mérete prím szám 25

Dupla hashing Két hash függvényt használunk A lépésközt is hash függvény határozza meg insert(kulcs, ertek) { h = hash(kulcs) mod n; h2 = (hash(kulcs) mod (n 1)) + 1 while(tabla[h]!= ures) { h = (h + h2) mod n; } tabla[h] = kulcs és ertek; } 26

Működés feltételei: Dupla hashing h2 soha nem lehet nulla, mert végtelen ciklust kapnánk A hash tábla mérete vagy prím szám legyen vagy kettő hatványa Ha a tábla mérete kettő hatványa akkor a lépésköz csak páratlan lehet 27

Rehashing Néha a tábla megtelik, vagy a műveletek nagyon lelassulnak, ilyenkor új táblát kell felépíteni A régi tábla minden élő kulcsát kivesszük és az új nagyobb táblába áttesszük Lassú és számítástechnikailag drága, ritkán alkalmazzuk Másik módszer hozzunk létre egy új táblát és ellenőrizzük mindkét táblában ha keresünk amikor az új táblába illesztünk, akkor a régiből vigyünk át k db elemet Ha minden elemet átvittünk, töröljük a régi táblát 28

Legjobb eset: O(1) Legrosszabb eset: O(n) Teljesítmény Legnagyobb hatással a teher faktor (load factor) van: használt helyek /tábla mérete Mindegyik ütközés feloldás működik 0.5 alatt. 0.5 felett folyamatosan romlik a teljesítmény 29

Absztrakt adattípus Asszociatív tömbök Egyedi, tetszőleges kulcsokhoz tetszőleges érték rendelhető Kulcs és érték közötti kapcsolat: mapping Legfontosabb művelet: Keresés (lookup) vagy indexelés Kulcshoz tartozó érték megtalálása Leggyakoribb alkalmazás például memoization 30

Memoization, kitérő Optimalizáló (Javító, gyorsító) technika Olyan programoknál használható ahol egy függvény ismételt meghívását akarjuk gyorsítani, mivel a korábbi eredményeit eltároljuk és azt használjuk ismételt hívásnál Donald Michie, 1968-ban adta ezt a nevet a technikának Memorandum (latin), emlékezés 31

Memoization Lényegében az időt helyre cseréljük Futási idő helyett tárolni kell az adatokat Példa memoization nélkül: Függvény faktoriális(n) if n == 0 visszatérési érték: 1 else visszatérési érték: n * faktoriális(n-1) if vége Függvény vége 32

Memoization Az eredeti függvény hol tölti az időt? Függvény hívás során a verem előkészítése Nullával való összehasonlítás n-1 kiszámítása a visszatérési érték tárolása a szorzás végrehajtása 33

Memoization Függvény faktoriális(n) if n in asszoc-tömb visszatérési érték: lookup(n, asszoc-tömb) if n == 0 visszatérési érték: 1 else x = n * faktoriális(n-1) if vége tárol(x, asszoc-tömb) visszatérési érték: x Függvény vége 34

Memoization Az új függvény hol foglal helyet? A lookup függvény egy adatszerkezetet használ ami függvény hívások között is megmarad! Példa: Perzisztens adatszerkezet faktoriális(5) faktoriális(4) már tárolja az értéket 35

Implementálás Asszociatív tömbök Hasító táblával Egyensúlyozott bináris fával telephone[ peter']='01-1234-56 telephone[ miklos']='02-4321-56' Név peter miklos Telephone 01-1234-56 02-4321-56 36

Asszociatív tömbök Hasító tábla jobb mivel O(1), fa pedig O(log N) Fa szerkezet kisebb lehet a memóriában Jó hash függvény kell, ami nehéz lehet Fa szerkezet valamilyen sorrendet őriz, hasító tábla esetén nehéz végig menni az összes elemen Hasító tábla fix méretű, esetleg rehashing kell ami rontja a hatékonyságot Fa szerkezet mindig O(log N) bonyolultságú, de a memóriában fragmentációt okozhat 37

Script nyelvekben: Asszociatív tömbök awk, perl, tcl, Javascript, Python, Ruby Programozási nyelvek Smalltalk, Objective-C,.NET, Common Lisp PHP, korlátozott (csak egész szám és szöveg) 38