Algoritmusok és adatszerkezetek

Az előadások a következő témára: "Algoritmusok és adatszerkezetek"— Előadás másolata:

1 Algoritmusok és adatszerkezetek
JPTE tavasz Kilián Imre Software H-7683 Gyűrűfű Cseresznyéskert tel:

2 Mit tanultunk tavaly? Algoritmusok fogalma, fajtái, szekvenciális algoritmusok leírási módjai, tervezési módszerei Indukció, rekurzió, „oszd meg és uralkodj”, mohó algoritmusok, dinamikus programozás Algoritmusok hatékonyságvizsgálata, növekedési rend, függvények aszimptotikus viselkedése Típusok: egyszerű, összetett, absztrakt, konkrét, korlátos/korlátlan méretű. Gyűjteménytípusok (collections). Típusok megadása UML osztálydiagramokkal. Tömbök, halmazok, fájlok, rekordok

3 Mit tanultunk tavaly? Vermek és sorok. Láncolt listák.
Kupactípus és alkalmazása elsőbbségi soroknál Rendezések: összehasonlító rendezések (buborék, beszúró, összefésülő, kupac- és gyorsrendezés). Diszjunkt halmazok Gráfok: fajtái és ábrázolásuk. Gráfműveletek. Gráfalgoritmusok: bejárások/keresések, topologikus rendezés, erősen összefüggő komponensek, optimális feszítőfa, legrövidebb utak, tranzitív lezárt képzése Lineáris programozás

4 Mi lesz az idén? (csak 1+1 óra hetente!)
Kiválasztási és keresési algoritmusok Fa adatszerkezetek Valószínűségi elemzések +++ stb.

5 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

6 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.

7 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.

8 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

9 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 -

10 Ü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ő

11 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)

12 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ő)

13 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.MFC (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”

14 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)

15 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 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?

16 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

17 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

18 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

19 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…

20 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 *

21 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

22 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ó)

23 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

24 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

25 Műveletek és megvalósítás
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) 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 Egyirányú? 1 1 Objektumorientált szemlélet Nem objektumorientált (hagyományos) szemlélet

26 (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

27 minimum():BinárisFa if balfa<>NIL then return balfa
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

28 Beszúrás Addig keresünk a fában, amíg NIL-hez jutunk.
Beszúr(r:KulcsosRekord) szülő=NIL, gyerek=Me while gyerek<>NIL do szülő=gyerek 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 eljárás üres fára nem működik Az összehasonlítás eredményét meg is őrizhetjük Konstruktor, amely egy tartalomrekordból létrehoz egy elemi fát

29 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

30 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 legfeljebb 1 gyereke van Kivágás átnyilazással? Ha a megelőzőjét vágtuk ki, akkor a tartalom átmásolása

31 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

32 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

33 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é)

34 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

35 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