Algoritmusok és adatszerkezetek PTE-TTK 2008. ősz Kilián Imre Software H-7683 Gyűrűfű Cseresznyéskert kilian@gamma.ttk.pte.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.

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ő Réka Csaba Torda Álmos Csaba Géza Álmos Előd Tas Á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 JobbraForgat():Fa újfa=balfa balfa=balfa.jobbfa újfa.jobbfa=Me return újfa y x a b c y x a b c Forgatás jobbra Forgatás balra

Faműveletek: dupla forgatás Jobbra2Forgat():Fa újfa=balfa.jobbfa újfa.balfa.jobbfa=balfa.jobbfa.balfa balfa=balfa.jobbfa.jobbfa újfa.jobbfa=balfa return újfa y z d c b x a z y x Forgatás jobbra Forgatás balra a b c d

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

Fibonacci számok A következő sorozat: F0=0, F1=1, Fk+1+ Fk = Fk+2 . Pl. 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233,… Aranymetszés: f=(1+sqr(5))/2=1.61803 Konjugáltja: f’=(1-sqr(5))/2 = -0.6183 Tétel: Fi=(fi-f’i )/sqr(5) a Fibonacci számok exponenciálisan nőnek.

AVL fák (Adelson-Velskij-Landis) Def: AVL-tulajdonság: Egy fa AVL fa, ha minden x csúcsára |h(x.bal)-h(x.jobb)|<=1 Mennyi a a k magasságú AVL fák csomópontjainak minimális száma (Gk)? G1=1, G2=2, G3=4, G4=7,… k>=3 esetén: Gk=1+Gk-1+Gk-2 Tétel: Gk= Fk+2+1, ha k>=1 Biz: 0,1-re nyilvánvaló. k>2-re indukcióval: Gk=1+Gk-1+Gk-2=1+Fk-1-1+Fk-2-1 Következmény: egy n csomópontú AVL-fa k magassága nem nagyobb, mint O(log n). k<=1.44*log(n+1). Biz: n>=Fk-2-1 Fibonacci becslésből: n+1>=fk  k<=logf(n+1) k<=1.44*log(n+1)

AVL kiegyensúlyozó algoritmus Tétel: Ha S egy n csúcsú AVL fa, akkor a Beszúr művelet után legfeljebb egy forgatással helyreállítható az AVL tulajdonság  a beszúrás költsége ezután is O(log n) marad. Miért? Minden csúcsban tároljuk az itt gyökerező részfa magasságát. Beszúrás után az új elemhez vivő út bejárásával megkapjuk az első olyan elemet, ahol az AVL tulajdonság először megsérülitt végzünk forgatást Tétel: Ha S egy n csúcsú AVL fa, akkor a Töröl művelet után legfeljebb 1.44*log(n) forgatással helyreállítható az AVL tulajdonság Biz nélkül…

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 0<A<1 egy állandó, k*A*mod 1: kA 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 próba=max 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 próba=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 Tétel: Sikertelen keresés várható próbaszáma legfeljebb: 1/(1-a) 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: 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 Beszúrás időigénye legfeljebb: 1/(1-a)

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 Tétel: 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ó, a keresés nem fut végig, átlagolni kell) 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…