Algoritmusok és adatszerkezetek JPTE 2006. ősz Kilián Imre Software H-7683 Gyűrűfű Cseresznyéskert tel: +36-73-554412 kilian@axelero.hu

Kiválasztási/keresési feladat Legabsztraktabb megfogalmazás: Tábla-Rekord-Mező – Rendezhető típusok sorszámmal indexelhető összetevőkkel, keresés ciklusban (lineárisan) Absztrakt megfogalmazás: KereshetőTábla-KulcsosRekord-Kulcs Keresésre önálló eljárás Kulcs: rendezési relációval

Konkrét keresési feladat (nem pontos!) Keresés időszükséglete (átlagban): Θ(n) Indexelés időszükséglete (kötött szélességű, sorszámmal indexelt vektorokban) állandó Cím szerintitartalom szerinti keresés Határozatlanságok: téridő, felgyorsulólelassuló műveletek Megoldás: keresőszerkezetek építése Alkalmazás: adatbázisokban, fordítóprogramok szimbólumtáblájában stb.

Még konkrétabban 0. Milyen gyűjtemény? Halmaz? Csomag? Vektor 1. beszúrás. Mi legyen, ha már létezik? Szúrja be újabb példányként is… 2. törlés. Mi legyen, ha nem létezik? Semmi. Ilyenkor ne töröljön. Mi legyen, ha több is létezik? Az elsőt törölje ki. 3. keresés. Mi legyen, ha több példány is létezik? Az elsőt találja meg. Mi legyen, ha nem található a keresett elem? Adjon hibaeredményt.

Hasító (hash) táblázatok (Hasonlít az edényrendezéshez) Műveletek: Keres, Töröl, Beszúr Legrosszabb eset: Θ(n), de átlagban Θ(1) is elérhető Legegyszerűbb modell: legrosszabb eset: Θ(1) Tfh. a lehetséges kulcsok egy véges egészintervallumból valók, vagyis min<=kulcs<=max. Index-tábla felvétele Keres(k) return(Index(k)) Beszúr(x) Index(kulcs(x))=x Töröl(x) Index(kulcs(x))=NIL 0| 2| 3| 6| 8| 9| Index/Cím- tábla Tábla rései Index megismétlése nem szükséges Rekord tartalma

Hash táblázatok nagy kulcstérben A teljes kulcstér (U) nagy (az indextábla nem ábrázolható) de az aktuálisan használt tér (K) kicsi (is lehet)  UK indextábla leképezés A K tér pontos mérete csak futásidőben derül ki UT hash tábla közötti leképező hash függvény T=h(U). Elnevezés: h(k) a k kulcs hash értéke Probléma: h(U) nem feltétlenül egy-egyértelmű, azaz előfordulhat, hogy h(k1)=h(k2) kulcsütközés Milyen legyen a h hash függvény? Jól szórjon – minél véletlenszerűbb -

Ütközésfeloldás láncolással Alapötlet: az ütköző (ugyanazon címre leképeződő) elemeket láncolt listába összefogjuk Beszúr(x) hash=h(kulcs(x)) if T(hash)<>NIL then T(hash).Beszúr(x) else T(hash)=LáncLista(x) Keres(x) hash=h(kulcs(x)) if T(hash)=NIL then return NIL else return(T(hash).Keres(x)) Töröl(x) hash=h(kulcs(x)) if T(hash)<>NIL then T(hash).Töröl if T(hash).Méret=0 then T(hash)=NIL alma baba nemez zászló alföld német nő

Láncolásos hasító technika elemzése Legrosszabb eset: egyetlen láncolt lista Kitöltöttségi arány (a=n/m), ahol n a tárolt elemek összes száma, m a hash-tábla hossza Tétel: láncolt hasító technika és egyenletes hash függvény esetén, az átlagos keresési idő: Θ(1+ a). Biz: az átlagos keresési idő az átlagos lista végigjárásával arányos (sikeres és sikertelen keresés) Következtetés: 1. Fix hash-tábla esetén, sok elemre lineáris Θ(n) 2. Ha a hash-tábla a tárolt elemekkel arányosan nő, ill. kevés a tárolt elem, akkor Θ(1)

Hasító függvények Mikor jó a hasító függvény? Ha a láncok kb. egyenletesen nőnek<=azaz a T(y) index egyenletes Mivel T(y)=T(h(U(x))), függ az U(x) kulcseloszlástól Milyen az U(x) eloszlása? - fordítóprogramok: egymáshoz közeli szimbólumok H eloszlása független legyen az adatok esetleges szabályszerűségeitől - pl. a kulcs maradéka egy prímszámra nézve Feltételezzük, hogy a kulcs egész (ha nem az, akkor leképezhető)

Hasító függvények Osztásos módszer: h(k)=k mod m, ahol m a hash tábla mérete Szorzásos módszer h(k)=m*(k*A mod 1)), ahol A egy állandó, mod 1: törtrészképzés Pl. tfh: k belefér egy gépi szóba, és m=2p. Ekkor k*(A*m) egy gépi szorzás2 szó, ez mod m az alsó p bit levágását jelenti. (Donald Knuth) Minden rögzített hasító függvényhez létezik „rossz” adat (csak 1 lánc jön létre, Θ(n) elérés)  a tényleges függvényt adott függvényosztályból véletlenszerűen (és adatfüggetlenül) választjuk ki. „Univerzális hasítási technika”

Nyílt címzés Nyílt címzésű a hash tábla, ha az adatok NEM láncolt listában, hanem benn a táblában vannak tárolva. Ütközés esetén újabb és újabb pozíciókat próbálunk ki, amíg csak üresre nem bukkanunk a tábla betelhet nincs mutató, nincs láncolt lista a kipróbálandó rések címét a hash függvény (a kipróbálási számtól is függően) adja meg adott kulcshoz a hash függvény a T címtér egy permutációját adja meg (vagyis mindent kipróbál)

Beszúr(kulcs) próba=0 repeat index=h(kulcs,próba) if hash[index]=NIL then hash[index]=k return else próba=próba+1 endif until i=m error „hash tábla túlcsordulás” Keres(kulcs) próba=0 repeat index=h(kulcs,próba) if hash[index]=kulcs then return index; else próba=próba+1 until hash[index]=NIL or i=hash.max return NIL Törlés: NIL-re állítás… Mi lesz az utána következő elemekkel?

Lineáris kipróbálás Négyzetes kipróbálás Ha van egy h:U[0,1,…m-1] hash függvényünk, akkor a lineáris kipróbálás függvénye a következő lesz: h’(k,i)=(h(k)+i) mod m. Hátránya: teljes szakaszokat betöltha egy jól szóró hash függvény belecímez, esetleg igen sok kipróbálásra kerül sor Négyzetes kipróbálás Ha van egy h:U[0,1,…m-1] hash függvényünk, akkor a négyzetes kipróbálás függvénye a következő lesz: h’(k,i)=(h(k)+c2*i2+c1*i) mod m. Hátrányai: 1. Ha a c1,c2 konstansokat rosszul választjuk, akkor nem címzi be a teljes táblát 2. Ugyanoda címző elemek esetében ugyanazt a sorozatot járjuk be

A nyílt címzéses hash technika elemzése Kitöltöttségi arány (a=n/m), ahol n a tárolt elemek összes száma, m a hash-tábla hossza  a<=1 Tfh. A hasítás egyenletes, vagyis egy (h(k,0), h(k,1),…h(k,m-1)) kipróbálási sorozat egyenletesen állítja elő a (0,1,…,m) sorozat permutációit. Legyen pi annak valószínűsége, hogy pontosan i próba talál foglalt rést. (0<=i<=n-1), i>n-re pi=0 A próbák számának várhatóértéke tehát: 1+i=0Σ∞i*pi Legyen qi annak valószínűsége, hogy legfeljebb i próba talál foglalt rést. (aztán jön a szabad) i=0Σ∞i*pi = i=0Σ∞qi (annak a vlsz, hogy pontosan 0;1;… próba talál rést, ugyanannyi, mint a vlsz., hogy legfeljebb 0;1;… próba talál rést

A nyílt címzéses hash technika elemzése Mennyi a qi-k értéke? q1=n/m annak a vlsz., hogy az első próba foglalt elemet talál q2=n/m*(n-1)/(m-1) qi=n/m*(n-1)/(m-1)*…*(n-i+1)/(m-i+1)<= ai A próbák számának várhatóértéke: 1+i=0Σ∞i*pi=1+ i=0Σ∞qi <=1+a1 +a2 +a3 +...=1/(1-a) 1. Elem biztos, 2. Elem a, 3. Elem a2... Ha félig van kitöltve, akkor próbaszám=2 lépés Ha 90%-ig van kitöltve, akkor próbaszám=10 lépés

A nyílt címzéses hash technika elemzése Kitöltöttségi arány (a=n/m), ahol n a tárolt elemek összes száma, m a hash-tábla hossza  a<=1 Ilyenkor a sikeres keresés várható próbaszáma: 1/a*ln(1/(1- a)) Bizonyítás nélkül… (az előzőhöz hasonló) 50% kitöltöttségre: 1,387 90% kitöltöttségre: 2.559  a nyílt címzéses hash technika a keresés optimálását a beszúrás lassulásán keresztül éri el…

Fák (kicsit különböző fogalmak) Nyílt fa (fa): összefüggő, körmentes, irányítatlan gráf (nincs kitüntetett csúcs, nincs gyökér) Erdő: nem összefüggő Tulajdonságai. Az alábbi állítások egyenértékűek: 1. G=(E,V) egy nyílt fa 2. G bármely két csúcsához egyértelműen tartozik egy őket összekötő egyszerű út G összefüggő, de bármely élének elhagyása után már nem az G összefüggő, és |E|=|V|-1 G körmentes, és |E|=|V|-1 G körmentes, de akár egyetlen éllel is bővítve, már nem az Bizonyítások: 12, 23, 34, 45, 56,61 *

Fák Gyökeres fák: egy pont kitüntetett x-ben gyökerező fa gyökér Gyökeres fák: egy pont kitüntetett x-ben gyökerező fa Legyen x gyökér. Az xw út elemeit w megelőzőjének nevezzük. Ha x megelőzője y-nak, akkor y rákövetkezője x-nek. Szülő, gyerek, testvér, fokszám Fa szintjei, magassága x y v w z u Belső pont gyökér

Fák Rendezett fa: ha minden csúcs gyerekei rendezettek (létezik, értelmezünk, használunk rendezési relációt, akár az elemek feletti rendezés, akár sorbaállítás) Kétágú (bináris) fák, amelyek - vagy nem tartalmaznak csúcsot - vagy a csúcsai 3 diszjunkt halmazba sorolhatók: a gyökér, a bal(rész)fa és a jobb(rész)fa, mindketten bináris fák A balfa gyökere: bal gyerek, jobbfáé: jobb gyerek Ha valamelyik részfa üres: hiányzó gyerek NEM: rendezett fa, melyben a fokszám legfeljebb 2 (azért, mert a mindkét részfa lehet hiányzó)

Fák K-ágú teljes fák: melyekben nincsenek részben hiányzó gyerekek/a csúcsok fokszáma vagy 0 (levél) vagy K, ÉS a minden levél magassága egyforma H. Tétel: K-ágú teljes fák leveleinek a száma: KH. Tétel: K-ágú teljes fák csúcsainak a száma: 1+K+K2+…+KN =i=0Σh-1Ki = (Kh-1)/K-1 Teljes bináris fa 3 2 7 4 1 5 6 3 2 7 4 1 5 6 Nem teljes fa

Bináris keresőfák Adatszerkezet, amely a keresést felgyorsítja. Átlagosan: Θ(log(n)), legrosszabb esetben: Θ(n) Használat: elsőbbségi sorként, ill. szótárként Bináris keresőfa tulajdonság: minden v csúcsra: v.bal<v<v.jobb, ha létezik balfa, ill. jobbfa Ugyanahhoz a halmazhoz több ilyen fa is építhető Tas Csaba Torda Álmos Csaba Géza Álmos Előd Réka Árpád Előd Réka Árpád Csilla Géza Csenge Torda Csenge Csilla Tas

Műveletek és megvalósítás Egyirányú? 1 1 Futásidő: O(h) keres(k:Kulcs):KulcsosRekord if k=tartalom.kulcs then return tartalom if k<tartalom.kulcs then return balfa.keres(k) else return jobbfa.keres(k) Objektumorientált szemlélet

Nem objektumorientált (hagyományos) szemlélet keres(f:BinárisFa,k:Kulcs):KulcsosRekord while f<>NIL és k<>f.tartalom.kulcs do if k<f.tartalom.kulcs then f=f.balfa else f=f.jobbfa return f Nem objektumorientált (hagyományos) szemlélet

(Nem csak kereső) -Fák bejárása Szimbólumtábla kiíratás abc-rendben InorderBejárás() if balfa<>NIL then balfa.InorderBejárás() print tartalom.kulcs if jobbfa<>NIL then jobbfa.InorderBejárás() PreorderBejárás() print tartalom.kulcs if balfa<>NIL then balfa.PreorderBejárás() if jobbfa<>NIL then jobbfa.PreorderBejárás() PosztorderBejárás() if balfa<>NIL then balfa.PosztorderBejárás() if jobbfa<>NIL then jobbfa.PosztorderBejárás() print tartalom.kulcs Függvényszerű alak képzése Fordított lengyel alak képzés

Benne van az adatszerkezetben? minimum():BinárisFa if balfa<>NIL then return balfa.minimum() else return Me maximum():BinárisFa if jobbfa<>NIL then return jobbfa.maximum() else return Me következő():BinárisFa if jobbfa<>NIL then return jobbfa.minimum() következő(k:Kulcs):BinárisFa ez = keres(k) if ez=NIL return NIL ez=ez.következő() if ez<>NIL return ez az = ez.őse while az<>NIL és ez=az.jobb ez=az; az=az.őse return az Benne van az adatszerkezetben? HF1: az eljárást megírni „őse” nélkül. (keres kifejtésével) HF2: az „előző” eljárást megírni

Beszúrás Addig keresünk a fában, amíg NIL-hez jutunk. Az eljárás üres fára nem működik Addig keresünk a fában, amíg NIL-hez jutunk. Beszúr(r:KulcsosRekord) szülő=gyerek=Me while gyerek<>NIL do szülő=gyerek if r.kulcs=szülő.tartalom.kulcs then hiba „Már benne van!”, return if r.kulcs<szülő.tartalom.kulcs then gyerek=szülő.balfa else gyerek=szülő.jobbfa if r.kulcs<szülő.tartalom.kulcs then szülő.balfa=new BinárisFa(r) else szülő.jobbfa=new BinárisFa(r) Az összehasonlítás eredményét meg is őrizhetjük FaKonstruktor

Törlés ha nincs gyereke, akkor töröljük a rámutatót ha egy gyereke van, akkor a rámutató a gyerekre mutat ha két gyereke van, akkor kicseréljük vagy a balfa legnagyobb, vagy a jobbfa legkisebb elemével Csaba Csilla törlése Csaba Álmos Előd Álmos Előd Árpád Csilla Géza Árpád Géza Csenge Csenge Árpád Álmos Előd Csilla Géza Csaba törlése Csenge

törlés(k:Kulcs) csúcs=keres(k) if csúcs. bal=NIL vagy csúcs törlés(k:Kulcs) csúcs=keres(k) if csúcs.bal=NIL vagy csúcs.jobb=NIL then vág=csúcs else vág=előző(csúcs) if vág.bal=NIL then fia=vág.jobb else fia=vág.bal if fia<>NIL then fia.őse=vág.őse if fia=vág.bal then vág.őse.bal=fia else vág.őse.jobb=fia if csúcs<>vág then csúcs.tartalom=vág.tartalom Mit is vágunk ki? Aminek 1 gyereke van vagy 1 sincs Ha nem a megelőzőjét vágjuk, akkor kivágás átnyilazással Ha a megelőzőjét vágtuk ki, akkor a tartalom átmásolása

Keresőfák egyenlő kulcsokkal A Beszúr eljárás módosítása: a fa tulajdonságot <= kell módosítani… 1. stratégia: minden elemhez vegyünk fel egy láncolt listát az egyenlő kulcsú elemek tárolására. 2. stratégia: az új, megegyező kulcsú elemet hol a bal, hol a jobb részfában tároljuk váltakozva 3. stratégia: a bal és jobb részfát véletlenszerűen váltogatjuk (a balfa legjobboldalsó/legnagyobb elemeit, ill. a jobbfa legbaloldalsó/legkisebb elemeit építjük láncszerűen tovább) Csaba Lánc kialakulása Álmos Előd Árpád Csilla Géza Csenge Később érkező elem Előd Előd Előd Fajsz

Radix fák (kódfák) Def: a jelsorozat lexikografikusan kisebb b-nél, ha 1, a első b-étől különböző eleme kisebb. 2. Ha a előtagja b-nek. (abc szerinti rendezés) A jelsorozatok tárolása nem szükséges 10 01 0011 1 00 001

Véletlen építésű keresőfák Adott kulcskészlethez többféle keresőfa is felépíthető (a beszúrás sorrendjétől függően). Def: Építsünk keresőfát n db. elemből. Ha mindegyik sorrend (permutáció) egyformán vlsz, akkor véletlen építésű keresőfáról beszélünk. Def: Kiegyenlített a fa, ha a levelek magassága közel megegyező Tétel: Egy n különböző kulcsot tartalmazó véletlen építésű keresőfa átlagos magassága O(lg(n)) Biz nélkül… vagyis a kiegyenlített fák létrejötte sokkal vlszbb, mint különböző degenerációiké (pl. láncoké)

Faműveletek: forgatás A forgatási műveletek megőrzik a fatulajdonságot Használatuk: pl. fakiegyensúlyozáskor BalraForgat():Fa újfa=balfa balfa=újfa.jobbfa újfa.jobbfa=Me return újfa y x a b c y x a b c Forgatás balra Forgatás jobbra

Piros-fekete fák Beszúrás, ill. törléskor a fa elveszítheti az egyensúlyát. A piros-fekete fák: az egyensúly megtartását biztosítják. +1 bit információ (szín)a legrövidebb és leghosszabb út legfeljebb 2-szeres arányú lehet Fatulajdonságok: - minden csúcs vagy fekete, vagy piros - minden levél fekete - minden piros csúcs mindkét utódja fekete - bármely két azonos csúcsból a levélig jutó útban ugyanannyi fekete csúcs van