390 likes | 627 Views
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,
E N D
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 szerintitartalom szerinti keresés • Határozatlanságok: téridő, 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: 12, 23, 34, 45, 56,61
x z y v u w gyökér Fák • Gyökeres fák: egy pont kitüntetett • x-ben gyökerező fa • Legyen x gyökér. Az xw ú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 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ó)
3 3 2 7 2 7 4 1 5 4 1 5 5 6 5 5 5 6 5 5 5 5 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 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
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
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
Az eljárás üres fára nem működik Beszúrás Az összehasonlítás eredményét meg is őrizhetjük • Addig keresünk a fában, amíg NIL-hez jutunk. • Beszúr(r:KulcsosRekord)szülő=gyerek=Mewhile 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ő.jobbfaif r.kulcs<szülő.tartalom.kulcs then szülő.balfa=new BinárisFa(r)else szülő.jobbfa=new BinárisFa(r) 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
Mit is vágunk ki? Aminek 1 gyereke van vagy 1 sincs • törlés(k:Kulcs)csúcs=keres(k)if csúcs.bal=NIL vagy csúcs.jobb=NIL then vág=csúcselse vág=előző(csúcs)if vág.bal=NIL then fia=vág.jobbelse fia=vág.balif fia<>NIL then fia.őse=vág.őseif fia=vág.bal then vág.őse.bal=fiaelse vág.őse.jobb=fiaif csúcs<>vág then csúcs.tartalom=vág.tartalom 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
0 1 0 1 00 01 10 001 0011 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
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é)
y x x a y c c b b a Faműveletek: forgatás • A forgatási műveletek megőrzik a fatulajdonságot • Használatuk: pl. fakiegyensúlyozáskor • JobbraForgat():Faújfa=balfabalfa=balfa.jobbfaújfa.jobbfa=Mereturn újfa Forgatás jobbra Forgatás balra
x y d z a b c Faműveletek: dupla forgatás • Jobbra2Forgat():Faújfa=balfa.jobbfaújfa.balfa.jobbfa=balfa.jobbfa.balfabalfa=balfa.jobbfa.jobbfaújfa.jobbfa=balfareturn újfa z x y Forgatás jobbra Forgatás balra c d b a
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ülitt 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…
6| 8| 9| 0| 2| 3| 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 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) • UK indextábla leképezés • A K tér pontos mérete csak futásidőben derül ki • UT 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 -
alma zászló baba nemez német alföld nő Ü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 NILelse return(T(hash).Keres(x)) • Töröl(x)hash=h(kulcs(x))if T(hash)<>NIL then T(hash).Törölif T(hash).Méret=0 then T(hash)=NIL
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ésPl. tfh: k belefér egy gépi szóba, és m=2p. Ekkor k*(A*m) egy gépi szorzás2 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 betelhetnincs mutató, nincs láncolt listaa 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 megadott kulcshoz a hash függvény a T címtér egy permutációját adja meg (vagyis mindent kipróbál)
Törlés: NIL-re állítás… Mi lesz az utána következő elemekkel? • 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
Lineáris 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öltha 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…