5. A gráf, mint adatstruktúra Gráfelméleti bevezető

Átírás

1 5. A gráf, mint adatstruktúra 5.1. Gráfelméleti bevezető Az irányított gráf (digráf) A G = ( V, E) rendezett párt irányított gráfnak (digráfnak) nevezzük. A rendezett pár elemeire tett kikötések: V véges halmaz, a G-beli csúcsok halmaza. E bináris reláció a V halmazon, az élek halmaza E = {( u, v) rendezett pár u V, v V} V V. Hurkok megengedettek. Hurok az ( a, a) él. Az irányítatlan gráf A G = ( V, E) rendezett párt irányítatlan gráfnak nevezzük. A rendezett pár elemeire tett kikötések: V véges halmaz, a G-beli csúcsok halmaza. E bináris reláció a V halmazon, az élek halmaza E = u, v rendezettlen pár u V, v V V. {( ) } V Hurok nem megengedett. Az u csúcsból kiinduló és a v csúcsba mutató él digráfban Az ( u, v) él. Az u csúcsból kiinduló és a v csúcsba mutató él irányítatlan gráfban Az ( u, v) él. Az u csúcs szomszédja Legyen ( u, v) él egy G = ( V, E) gráfban. Ekkor a v csúcsot az u csúcs szomszédjának nevezzük A szomszédság reláció irányítatlan gráfban szimmetrikus, digráfban nem. Csúcs fokszáma irányítatlan gráfban A csúcs fokszáma a belőle kiinduló élek száma. Csúcs fokszáma digráfban Kimenő fokszám (kifok): a csúcsból kimenő élek száma Bemenő fokszám (befok): a csúcsba bemenő élek száma Csúcs fokszáma: kifok+befok Ionizált csúcs Csúcs, melynek fokszáma zérus. Az u csúcsot az u csúccsal összekötő k hosszúságú út Csúcsok véges sorozata: v, v 1,,, ahol u = v, u' = v K v k k és ( vi 1, vi ) E, i = 1, K, k. Egyszerű út Út, melyben a benne szereplő csúcsok páronként különbözőek.

2 Adatstruktúrák, algoritmusok ahol u = v, u' = v k és ( vi 1, vi ) E, i = 1, K, k. Út része Legyen v, v 1,, út. Az út része v, v 1, K, v, ahol. K v k i i + j i j k Az u csúcs elérhető az u csúcsból Azt mondjuk, hogy az u csúcs elérhető az u csúcsból (jelölésben van olyan út, amely az u csúcsot az u csúccsal összeköti. Kör digráfban Út, melyre v = v k és az út tartalmaz legalább egy élt. Egyszerű kör Kör, melynek csúcsai mind különbözőek. Hurok 1 hosszúságú kör. Egyszerű gráf Hurok nélküli digráf Kör gráfban Egyszerű kör és k 3, v = vk. Körmentes gráf Gráf, amely nem tartalmaz kört.. Összefüggő gráf Ha bármely két csúcsa összeköthető úttal. u P u '), ha Összefüggő komponens Csúcsok alkotta ekvivalencia-osztály, ahol az ekvivalencia reláció a csúcsok közötti elérhetőség. Digráf erősen összefüggő Tetszőleges két csúcs esetén mindegyik elérhető a másikból. Izomorf gráfok A G = ( V, E) és a G ' = ( V ', E' ) gráfok izomorfak, ha létezik olyan u, v E f u, f v E. bijekció, hogy ( ) ( ( ) ( )) ' f : V V ' A G ( V, E) = gráf részgráfja G ' = ( V ', E' ) gráf, melyre V ' V és E' E. A G gráf V által meghatározott részgráfja ' V ', E' E' = u, v E, u, v V '. G = ( ), ahol {( ) }

3 Adatstruktúrák, algoritmusok A G ( V, E) = gráfhoz tartozó digráf Az a ' ( V ', E' digráf, melyre irányított éllel helyettesítjük). A G ( V, E) G = ) ( u v) E' ( u, v) E,, azaz az éleket két = digráfhoz tartozó irányítatlan gráf Az a G ' = ( V ', E' ) gráf, melyre ( u, v) E' u v, ( u, v) E azaz elhagyjuk a hurkokat és az irányítást. Tétel: Bizonyítás Teljes gráf Irányítatlan gráf, melyben bármely két csúcs szomszédos. (Minden lehetséges él benne van.) Páros gráf Irányítatlan gráf, melynél V felbontható V 1, V 2 diszjunkt unióra úgy, hogy ( u, v) E esetén vagy u V1 és v V2, vagy pedig u V2 és v V 1. (Azaz V1- ben és V 2 -ben nincs belső él.) Erdő Körmentes, irányítatlan gráf. (Nyílt) fagráf Összefüggő, körmentes, irányítatlan gráf. A nyílt fák tulajdonságai Legyen G = ( V, E) irányítatlan gráf. Az alábbiak ekvivalensek. 1. G nyílt fa 2. G bármely két csúcsához egyértelműen létezik egy őket összekötő egyszerű út. 3. G összefüggő, de tetszőleges élének elhagyása után a visszamaradó gráf már nem összefüggő 4. G összefüggő és E = V 1 5. G körmentes és E = V 1 6. G körmentes, de akár egyetlen éllel is bővítve E-t a kapott gráf már tartalmaz kört bizonyítása G fa G összefüggő. G bármely csúcspárja között van út. Be kell látni, hogy csak egy van. Ha több lenne, akkor kettőből már kör alakítható ki, ami ellentmondás bizonyítása G bármely két csúcsa egyértelműen köthető össze úttal. G összefüggő. Tetszőleges (u,v) élt választva az él az u és v csúcsokat köti össze egyelemű útként. Ő az egyetlen út u és v között. Ha elhagyom, akkor nem lesz ott út, tehát a gráf nem lesz összefüggő bizonyítása

4 Adatstruktúrák, algoritmusok G (3) miatt összefüggő, tehát ezt nem kell bizonyítani. Másrészt ebből adódóan automatikusan E V - 1. Teljes indukcióval látjuk be, hogy E V - 1. Legyen n= V. Ha n=1 vagy 2, akkor ez igaz, mert a gráfnak n-1 éle van. Legyen most n 3 és minden kevesebb csúcsú gráfra teljesüljön (3). Hagyjuk el tetszőleges élét. Ezáltal k darab összefüggő komponens keletkezik, ahol k 2. Minden komponens (3) tulajdonságú. Az élek száma legfeljebb n-k n-2. Az elvett élt is hozzávéve az élek száma legfeljebb n bizonyítása Indirekt módon bizonyítunk. Tegyük fel, hogy van kör. Erre a körre, mint részgráfra igaz, hogy éleinek és csúcsainak száma megegyezik. Legyen ez k. Ha k< V, akkor van még csúcs a körön kívül, mely szomszédos a kör valamely csúcsával G összefüggősége miatt. Vegyük hozzá a körhöz ezt a csúcsot és az élt. Az így kapott részgráfban is a csúcsok száma és az élek száma azonos (k+1). Újabb és újabb csúcsok és élek hozzávételével az összes csúcspontot felhasználjuk. Ekkor G-re azt kapjuk, hogy E V, ami ellentmondás bizonyítása Legyen G összefüggő komponenseinek száma k. Minden komponens fa és (1) (5). Ezért G komponenseiben V - k él van. E = V - 1 miatt k=1 és így G fa. Ekkor viszont bármely két G-beli csúcs összeköthető egyszerű úttal. Hozzávéve egy új élt a két csúcs között, az az úttal együtt kört alkot bizonyítása Azt kell belátni, hogy G összefüggő. Legyen u,v két tetszőleges csúcs. Ha szomszédosak, akkor van közöttük út. Ha nem szomszédosak, akkor vegyük fel az u,v élt. Ekkor kör keletkezik (6) miatt, A kör élei az (u,v) él kivételével G-hez tartoznak.és így utat alkotnak u és v között. Tehát G összefüggő, tehát fa Gyökeres fák Gyökeres fa T fagráf, amely egyik csúcsának kitüntetett a szerepe a többihez képest. Ez a csúcs a gyökér vagy gyökércsúcs (r). Az x csúcs megelőzője A gyökérből x-be vezető úton fekvő bármely csúcs. (x is a saját megelőzője.) y valódi megelőzője x-nek ha megelőzője x-nek, de y x. x az y rákövetkezője ha y x-nek megelőzője. (x is a saját rákövetkezője.)

5 Adatstruktúrák, algoritmusok x valódi rákövetkezője y-nak ha megelőzője y-nak, de y x. x-ben gyökerező részfa Az x és a rákövetkezőiből álló részgráf (fa). x szülője y ha az r P x úton (y,x) az utolsó él. (A gyökérnek nincs szülője T-ben.) x az y gyereke ha y az x szülője. Testvérek azok a csúcsok, amelyeknek ugyanaz a csúcs a szülője. Külső csúcs vagy levél az a csúcs, amelynek nincs gyereke. Belső csúcs az a csúcs, amely nem levél. x fokszáma gyökeres fában az x gyerekeinek száma. (A szülő nem számít bele a fokszámba!) x szintje az r P x út hossza. T magassága a T-beli csúcsok szintjei közül a legnagyobb. Rendezett gyökeres fa minden csúcs gyerekei rendezettek. (Azaz van első, második,, k-adik) Bináris fa Rendezett fa, melyben minden csúcs fokszáma legfeljebb kettő. (Beszélhetünk bal gyerekről és jobb gyerekről.) Null fa Üres bináris fa. Teljes bináris fa Bináris fa, melyben a csúcsok fokszáma kettő, kivéve a leveleket, melyeké, valamint az összes levél azonos szinten helyezkedik el. Súlyozott fa A csúcsok gyerekeit különböző pozitív, egész számmal indexeljük. (1,2,3, ) csúcs i-dik gyereke hiányzó nincs i indexű gyereke. k-adrendű fa Súlyozott fa, ahol minden csúcsnál a k-nál nagyobb indexű gyerekek hiányoznak.

6 Adatstruktúrák, algoritmusok (A bináris fa másodrendű.) k-adrendű teljes fa k-adrendű fa, melyben a levelek ugyanazon szintűek és az összes belső csúcs fokszáma k. A h magasságú teljes k-adrendű fának k h számú levele van. Ha a levelek száma n, akkor a teljes k-adrendű fa magassága log k n. A h magasságú teljes k-adrendű fa belső csúcsainak a száma: h = h h i k k k K k k =. i= k 1 Teljes bináris fa belső csúcsainak száma: 2 h 1 A gyökeres fa adatstruktúra. A fa minden csúcsa egy objektum. Az objektumok tartalmaznak kulcs mezőt és mutatókat. A T fa attribútuma: gyökér[t] egy mutató, mely a fa gyökerére mutat. Ha gyökér[t]=nil, akkor a fa üres. Bináris fa esetén az x csúcs ábrázolható az alábbi sémával: Szülőmutató Kulcs Bal gyerek mutató Jobb gyerek mutató Csúcsattribútumok: szülő[x], kulcs[x], bal[x], jobb[x] Ha szülő[x]=nil, akkor x gyökér. Ha bal[x]=nil, vagy jobb[x]=nil, akkor amelyik NIL, az a gyerek nincs. Ha mindkettő NIL, akkor x levél. A bináris fa mintájára k-adrendű fa esetén használható, bár memória pazarló az x csúcs ábrázolására az alábbi séma: Szülő mutató Kulcs 1. gyerek mutató 2. gyerek mutató k. gyerek mutató Helyette javasolható az úgynevezett bal gyerek jobb testvér séma, melynek memóriaigénye: Ο( n). Szülőmutató Kulcs Bal gyerek mutató Jobb testvér mutató

7 Adatstruktúrák, algoritmusok NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL Bináris kupac, kupacrendezés A bináris kupac (heap) A bináris kupac (heap) egy bináris gyökeres fa, amely minden szintjén kitöltött, kivéve esetleg az utolsó szintet, ahol balról jobbra haladva vannak a levelek kihagyás nélkül (a szint balra tömörített) továbbá teljesül a kupac tulajdonság, mely szerint a gyökércsúcsot kivéve minden x mutatójú csúcsra fenn kell álljon, hogy Kulcs(Szülő(x)) Kulcs(x), ha maximumkupacról beszélünk, illetve Kulcs(Szülő(x)) Kulcs(x) minimumkupac esetén, A következőkben a maximumkupacról fogunk beszélni. Kupac attribútumok (feltételezve, hogy a kupac reprezentálása egy egyindexes A tömbbel történik, amelyben a kupacot tároljuk és amelynek indexelése 1-gyel kezdődik) a következők: hossz[a] a tömb fizikai maximális mérete (elemszám a tömbben). kupac_méret[a a kupacelemek (csúcsok) száma gyökér[t] ) A 1 Az i indexű elem esetén az attribútumok: Szülő(i), Bal(i), Jobb(i) Kupac magasság = a fa magassága = h = Θ( log n) Példa kupacra és tömbös realizációjára:

8 Adatstruktúrák, algoritmusok algoritmus algoritmus algoritmus Szülő Bal gyerek Jobb gyerek n = Θ 1 n = Θ 1 T n = Θ 1 // T ( ) ( ) // T ( ) ( ) // ( ) ( ) 1 SZÜLŐ( i, x ) BAL( i, x ) JOBB( i, x ) 2 // Input paraméter: i a vizsgált index // Input paraméter: i a vizsgált index // Input paraméter: i a vizsgált index 3 // Output paraméter: x a szülő indexe // Output paraméter: x a bal gyerek indexe 4 5 // Output paraméter: x a jobb gyerek indexe i x 2 x 2i x 2 i RETURN( x ) RETURN( x ) RETURN( x ) algoritmus Kupacol ( Eljárás a kupac tulajdonság fenntartására ) T n = Θ // ( ) ( logn) 1 KUPACOL ( A, i ) 2 // Input paraméter: A - a kupacot tároló tömb 3 // i - a vizsgálandó elem indexe 4 // Output paraméter: A - a kupacot tároló tömb 5 // Akkor használjuk, ha az i baloldali és jobboldali részfái ugyan kupacok, de i-ben sérülhet a kupac tulajdonság 6 BAL( i, b ) 7 JOBB( i, j ) 8 IF b Kupac_méret[A] és A b >A i 9 THEN legnagyobb b 1 ELSE legnagyobb i 11 IF j Kupac_méret[A] és A j >A legnagyobb

9 Adatstruktúrák, algoritmusok THEN legnagyobb j 13 IF legnagyobb i 14 THEN csere A i A legnagyobb 15 KUPACOL( A, legnagyobb ) 16 RETURN (A) algoritmus Kupacot épít (Eljárás, mely tetszőleges adatokból kupacot épít ) // T ( n) = Θ(n) 1 KUPACOT_ÉPÍT( A ) 2 // Input paraméter: A - a kiinduló kulcsok tömbje 4 // Output paraméter: A az elkészült kupac tömbje 5 6 Kupac_méret[A] hossz[a] hossz[ A] 7 FOR i 2 DOWNTO 1 DO 8 KUPACOL( A, i ) 9 RETURN ( A ) algoritmus Kupacrendezés (Eljárás, mely helyben rendez ) T n = // ( ) Θ( nlogn) 1 KUPACRENDEZÉS( A ) 2 // Input paraméter: A - a rendezendő kupac tömbje 3 // Output paraméter: A a rendezett kulcsok tömbje 4 5 KUPACOT_ÉPÍT( A ) 6 FOR i hossz[a] DOWNTO 2 DO 7 csere A 1 A i 8 DEC ( Kupac_méret[A] ) 9 KUPACOL( A, 1 ) 1 RETURN ( A ) algoritmus Kupacba beszúrás // T ( n) = Θ( logn) 1 KUPACBA_BESZÚR( A, kulcs ) 2 // Input paraméter: A - a kupac tömbje 3 // kulcs a beszárandó kulcs 4 // Output paraméter: A a kupac a beszúrt kulccsal 5 6 INC( Kupac_méret[ A ] ) 7 i Kupac_méret [A] ) 8 SZÜLŐ( i, x )

10 Adatstruktúrák, algoritmusok WHILE i>1 és A x <kulcs 1 A i A x 11 i x 12 SZÜLŐ( i, x ) 13 A i kulcs 14 RETURN ( A ) algoritmus Kupacban maximális kulcs lekérdezése T n = Θ ) // ( ) (1 1 KUPACBAN_MAX( A, max, hiba ) 2 // Input paraméter: A - a kupac tömbje 3 // Output paraméter: max a maximális kulcs 4 // hiba jelzi a művelet sikerességét 5 6 IF Kupac_méret[A]<1 7 THEN hiba kupac alulcsordulás 8 RETURN ( hiba ) 9 max A 1 1 hiba sikeres művelet 11 RETURN ( max, hiba ) algoritmus Kupacból a maximális kulcs lekérdezése eltávolítással T n = Θ log ) // ( ) ( n 1 KUPACBÓL_KIVESZ_MAX ( A, max, hiba ) 2 // Input paraméter: A - a kupac tömbje 3 // Output paraméter: max a maximális kulcs 4 // hiba jelzi a művelet sikerességét 5 6 IF Kupac_méret[A]<1 7 THEN hiba kupac alulcsordulás 8 RETURN ( hiba ) 9 max A 1 1 A 1 A Kupac_méret[A] 11 DEC( Kupac_méret[A] ) 12 KUPACOL( A, 1 ) 13 hiba sikeres művelet 14 RETURN ( max, hiba ) Az elsőbbségi sor Az elsőbbségi sor (priority queue) Az elsőbbségi sor (priority queue) olyan S halmaz, amelynek minden eleméhez egy kulcs értéket rendelünk. A kulcs egy elsőbbségi értéket, prioritási értéket szimbolizál. Szolgáltatást igénybevevők sorbanállási sorában a sorrakerülő elem az lesz, amelynek a prioritása a legnagyobb (maximum prioritásos sor), vagy amelyiké a legkisebb (minimum prioritásos sor).

11 Adatstruktúrák, algoritmusok BESZÚR(S,x): MAXIMUM(S): KIVESZ_MAX(S): egy elemet hozzáadunk S-hez. S S {x} S legnagyobb kulcsú elemének meghatározása megadja és törli a maximális kulcsú elemet. Az elsőbbségi sor célszerű realizációja a kupac A Huffman kód, a mohó algoritmus A Huffman kód egy adattömörítési célokat szolgáló eljárás. A probléma megfogalmazása: Legyen adott egy adatfile, amelyben ismert az egyes adatelemek (pl.: byte-ok) gyakorisága. A feladat olyan kódot találni az adatelemekre, amely révén a kódolt file hossza rövidebb lesz (a lehető legrövidebb), mint az eredeti hossz volt. Kódszó Kódszónak nevezzük az üzenet ábécé betűjéhez hozzárendelt jelek nemüres sorozatát, amelyben a kódábécé betűi szerepelhetnek. Kód Kódnak nevezzük az üzenet ábécé betűit és a hozzájuk rendelt kódszavak táblázatát. (Kódtábla, kódszótár). Kódolás Kódolásnak nevezzük az üzenet betűinek a helyettesítését a betűnek megfeleltetett kódszóval. A kódolás eredménye a kódolt üzenet. Az egyszerűség kedvéért a kódoláshoz használjunk két jelet, a és az 1 jeleket. Az adatelemek kódja lehet fix hosszúságú vagy lehet változó hosszúságú. A kódot egy kódfával ábrázolhatjuk, amely egy bináris fa, amelynek levelei a kódszavak. A kódszó a levélhez vezető útból olvasható ki a gyökértől indulva balra lépéskor, jobbra lépéskor 1 hozzáírásával a kódszóhoz. Dekódolás Dekódolásnak nevezzük a kódolt üzenet kódszavakra bontását. A kódnak dekódolhatónak kell lennie, ha azt akarjuk, hogy a dekódoláskor az eredeti üzenetet kapjuk vissza. Dekódolható kód Dekódolhatónak nevezzük a kódot, ha minden kódolt üzenet csak egyféleképpen bontható kódszavakra. Prefix kód Prefix kódnak nevezzük a kódot, ha egyik kódszó sem eleje semelyik másik kódszónak. (Semelyik kódszót sem lehet valamely másikból kódjelek hozzáírásával megkapni.) A prefix kód dekódolható kód. Dekódolható kódok ekvivalenciája Két dekódolható kódot ekvivalensnek nevezünk, ha a megfelelő kódszavaik

12 Adatstruktúrák, algoritmusok hossza megegyezik. Bizonyítható, hogy minden dekódolható kódhoz létezik vele ekvivalens prefix kód. Példa: Betű Gyakoriság Fix hossz Változó hossz c f(c) KódszóHosszKódszóHossz A B C D E F Megadjuk a két kód kódfáját. A téglalapok a fa levelei, a kódolandó ábécé betűi a gyakoriságokkal. A belső csúcsok körök, bennük a csúcs gyerekeinek gyakoriságösszege szerepel A: A:45 B:13 C:12 D:16 E:9 F: C:12 B:13 14 D:16 F:5 1 E:9 A fa költsége A fa költségének nevezzük a: ( T ) = f ( c) d( c) B számot, ahol c a C ábécé betűje, f(c) a betű gyakorisága és d(c) a betű mélysége a fában (kódszóhossz). c C A fa költségét leosztva a file-t alkotó betűk számával az egy betűre jutó átlagköltséget kapjuk, ami úgy is értelmezhető, mint az átlagos kódszóhossz. Ha ez kisebb, mint egy, akkor tömörítésről beszélünk. Optimális kód Optimális a kód, ha a fa költsége minimális.

13 Adatstruktúrák, algoritmusok Az optimális kód bináris fája mindig teljes. A Huffman-kód optimális kód. A Huffman-kód szerkesztése: Jelölje a kódolandó ábécé betűinek halmazát C és legyen a betűk száma n. A Huffman kód szerkesztési algoritmusának pszeudokódja kiindul egy prioritási sorból, amelyben a betűk a gyakoriságaik szerint vannak kulcsolva. Ezután n-1 lépésben mindig a két éppen akkor legkisebb gyakoriságú elemet összevonva felépít egy optimális kódfát. Az optimum nem egyértelmű, mert az optimális fában bármely csúcs bal és jobb gyerekét felcserélve újra optimális fát kapunk. Egy algoritmustervezési startégia a mohó algoritmus tervezése. Ezt a heurisztikát általában optimalizálásra használják. A mohó stratégia elve szerint az adott pillanatban mindig az ott legjobbnak tűnő lehetőséget választjuk a részprobléma megoldására, azaz a pillanatnyi lokális optimumot választjuk. Ez a választás függhet az előző választásoktól, de nem függ a későbbiektől. A mohó stratégia nem mindig vezet globális optimumra. A Huffman kód szerkesztési algoritmusa mohó algoritmus, mivel minden lépésben úgy von össze, hogy a költség a legkisebb mértékben növekedjen. A teljes fa költsége megegyezik az összevonási lépések költségének összegével. // algoritmus Huffman kód készítése T ( n) = Θ( nlogn) 1 HUFFMAN( C, T ) 2 // Input paraméter: C - a kódolandó abécé a gyakoriságokkal 3 // Output paraméter: T a kódfa 4 // 5 // Jelölje C az ábécé betűinek a számát 6 // Létrehozunk egy Q minimum prioritási sort az ábécé betűiből a gyakoriságot használva prioritásnak. A sor elemei fák lesznek, kezdetben minden fát egyetlen betű alkot. 7 Q C 8 FOR i 1 TO C 1 DO 9 PONTOT_LÉTESÍT(z) //Egy új z csomópontot hoz létre, melyet később a Q sorba be fogunk szúrni. Egy új fa gyökere lesz. 1 x Bal[z] KIVESZ_MIN(Q) //Kivesszük a Q sorból legkisebb elemet és az új z csomópont bal gyerekének nyílvánítjuk valamint elnevezzük x-nek átmenetileg 11 y Jobb[z] KIVESZ_MIN(Q) //Kivesszük a Q sorból a következő legkisebb elemet és az új z csomópont jobb gyerekének nyílvánítjuk valamint elnevezzük y-nak átmenetileg 12 f[z] f[x]+f[y] // Az új csomópontra meghatározzuk a gyakoriság értéket (prioritás) 13 BESZÚR(Q,z) // Az új z csomópontot beszúrjuk a Q sorba 14 KIVESZ_MIN( Q, T ) // A Q sor egyetlen elemét, mint eredményt Kivesszük a sorból

14 Adatstruktúrák, algoritmusok RETURN( T ) Példa: F:5 E:9 C:12 B:13 D:16 A:45 14 C:12 B:13 D:16 A:45 F:5 E:9 D: A:45 F:5 E:9 C:12 B: A:45 C:12 B:13 14 D:16 F:5 E:9 A: C:12 B:13 14 D:16 F:5 E:9

15 Adatstruktúrák, algoritmusok A: C:12 B:13 14 D:16 F:5 E: Diszjunkt halmazok adatstruktúra Diszjunkt halmazok adatstruktúra A diszjunkt halmazok adatszerkezet dinamikus halmazok S=(S 1,S 2,,S k ) együttese. A halmazok elemei objektumok. Mindegyik halmazt egy képviselője azonosít, mely eleme a halmaznak. Általában lényegtelen, hogy melyik ez az elem. Műveletei: HALMAZT_KÉSZÍT(x): Egy új halmazt hoz létre, melynek ez az egy x eleme lesz, amely egyúttal képviselője is. EGYESÍT(x,y): Az x-et tartalmazó S x és az y-t tartalmazó S y halmazokat egyesíti a két halmaz uniójává. Az eredmény az eredeti két halmaz helyére lép, azok megsemmisülnek. A közös képviselő az unió tetszőleges eleme lehet. HALMAZT_KERES(x): Visszaad egy mutatót, amely x halmazának a képviselőjére mutat. Egy alkalmazás diszjunkt halmazokra: megkeressük egy gráf összefüggő komponenseit algoritmus Gráf összefüggő komponenseinek megkeresése T n = Θ V + ) // ( ) ( E 1 ÖSSZEFÜGGŐ_KOMPONENSEK( G ) 2 // Input paraméter: G - a gráf 3 // Output paraméter: G a gráf a komponens információkkal 4 // 5 FOR v V[G] csúcsra DO 6 HALMAZT_KÉSZÍT( v ) 7 FOR (u,v) E[G] élre DO

16 Adatstruktúrák, algoritmusok IF HALMAZT_KERES( u ) HALMAZT_KERES( v ) 9 THEN EGYESÍT( u, v ) 1 RETURN( G ) Két kézenfekvő módszer kínálkozik a diszjunkt halmazok adatstruktúra realizálására: 1. a listás realizáció és a 2. gyökeres fákból álló erdős realizáció. A listás realizáció esetén mindegyik halmaz egy önálló lista. A lista első elemét kinevezzük képviselőnek. Mindegyik listaelemnek van egy mutatója, amely a lista következő elemére mutat és van egy, amely a képviselőre. A képviselő is visszamutat saját magára. Az EGYESÍT eljárás ilyenkor a két lista összekapcsolását jelenti, ahol a második listában minden elemnek a képviselő mutatót le kell cserélni az első lista képviselőjére mutató mutatóra. Példa: Két halmaz, az egyik az {a,b,c,d} elemekből áll, képviselőjük az a elem. A másik az {e,f,g} elemekből áll, képviselőjük az e elem. fej a b c d fej e f g Az összekapcsolás eredménye: EGYESÍT( a, e ) fej a b c d e f g Ugyanezen halmazoknak a gyökeres fás erdős realizációja lehet az alábbi. Az ábrán az egyesítés műveletének az eredménye is látható. gyökér a gyökér e gyökér e b d f a f c g b d g c

17 Adatstruktúrák, algoritmusok Diszjunkt halmaz erdőkre a pszeudokód az alábbi lehet. Megadjuk az összekapcsolás algoritmusát is, amely egy rang fogalmat használ. Minden elemhez hozzárendelünk egy nemnegatív rang számértéket. Ez kezdetben zérus, majd növekedhet. Az összekapcsolásnál a nagyobb rangú képviselő lesz az új képviselő, egyenlőség esetén a másodiknak megadott, melynek a rangját eggyel megnöveljük. Szülő[ x ] az x által mutatott elemnek a szülőjére mutató mutató, Rang[ x ] pedig az elem rang mezeje algoritmus Elemből halmaz készítése // T ( n) = Θ( 1) 1 HALMAZT_KÉSZÍT ( x ) 2 // Input paraméter: x mutató az elemre 3 // Output: az x mutatójú elem kiegészítve halmazinformációkkal 4 // 5 Szülő[ x ] x 6 Rang[ x ] 7 RETURN algoritmus Két diszjunkt halmaz uniója (összekapcsolása) T n = Θ 1 // ( ) ( ) 1 ÖSSZEKAPCSOL( x, y ) 2 // Input paraméter: x mutató az első halmaz képviselőjére // y - mutató a második halmaz képviselőjére 3 // Output: az összekapcsolt halmaz 4 // 5 IF Rang[ x ] > Rang[ y ] 6 THEN Szülő[ x ] x 7 ELSE Szülő[ x ] y 8 IF Rang[ x ] = Rang[ y ] 9 THEN INC (Rang[ y ]) 1 RETURN algoritmus Halmaz keresése T n = Θ h, h a fa magassága // ( ) ( ) 1 HALMAZT_KERES( x, y ) 2 // Input paraméter: x elem mutatója 3 // Output paraméter: y x halmaza képviselőjének mutatója 4 // 5 y x 6 IF y Szülő[ y ] 7 THEN HALMAZT_KERES( Szülő[ y ], y) 8 RETURN ( y ) algoritmus Két diszjunkt halmaz egyesítése

18 Adatstruktúrák, algoritmusok // T ( n) Θ( h) =, h a magasabb fa magassága 1 EGYESÍT( x, y ) 2 // Input paraméter: x az egyik elem mutatója 3 // y a másik elem mutatója 4 // Output: a két elem halmaza egyesítve 5 // 6 HALMAZT_KERES( x, u ) // u az x képviselője 7 HALMAZT_KERES( y, v ) // v az y képviselője 8 ÖSSZEKAPCSOL( u, v ) 9 RETURN Binomiális fák és binomiális kupac A binomiális fa A B k binomiális fa egy rekurzív módon rendezett fa. B egyetlen csúcsból áll, B k pedig két összekapcsolt B k-1 binomiális fából (k=1,2,3, ), ahol az egyik fa gyökércsúcsa a másik gyökerének legbaloldalibb gyereke. Alább szemléltetjük a B, B 1, B 2, B 3 binomiális fákat. B B 1 B 2 B 3 Tétel: A Binomiális fák tulajdonságai Ha B k binomiális fa, akkor 1. 2 k csúcsa van 2. A magassága k k 3. Az i-dik szinten (mélységben) pontosan (i =,1,2,,k) számú csúcs i van. 4. A gyökércsúcs fokszáma k, ami nagyobb, mint bármely más csúcs fokszáma; továbbá ha a gyökércsúcs gyerekeit balról jobbra megszámozzuk k-1, k-2,,1,-val, akkor az i. gyerek egy B i részfa gyökércsúcsa. Következmény: Egy n csúcsú binomiális fa minden csúcsának fokszáma legfeljebb log 2 n. A binomiális kupac Egy H binomiális kupac binomiális fák olyan halmaza, mely rendelkezik az alábbi úgynevezett binomiális-kupac tulajdonságokkal:

19 Adatstruktúrák, algoritmusok H minden binomiális fája kupac-rendezett, azaz minden csúcs kulcsa nagyobb vagy egyenlő, mint a szülőjének a kulcsa. 2. Bármilyen fokszámot tekintünk, H-ban legfeljebb egy olyan binomiális fa van, amelyikben a gyökércsúcs fokszáma a tekintett fokszám. Megjegyzés: Egy n elemű binomiális kupac legfeljebb log 2 n +1 binomiális fából áll. Ha felírjuk n kettes számrendszerbeli alakját, akkor a binomiális kupacban azok a binomiális fák szerepelnek, amelyeknek az indexe éppen megegyezik a szám alakjában a szereplő kettő hatvány kitevőjével. Például, ha 11 csúcs van a binomiális kupacban, akkor 11=111 2, ezért a kupac három fából áll és ezek a B 3, B 1, B fák. A binomiális kupac műveletei: BINOMIÁLIS_KUPACOT_KÉSZÍT(H) BESZÚR( H, x ) Egy új üres H kupacot készít és ad vissza A H kupacba beszúr egy olyan x csúcsot, amelynek a kulcsmezője már ki van töltve BINOMIÁLIS_KUPACBAN_MIN( H, min ) Visszaad egy olyan mutatót, amely a H kupacnak a minimális kulcsú csúcsára mutat KIVESZ_MIN( H, min ) EGYESÍT( H 1, H 2, H ) KULCSOT_CSÖKKENT( H, x, k ) TÖRÖL( H, x ) A H kupacból kiveszi azt a csúcsot, amelynek a kulcsa minimális, és visszaad egy erre a csúcsra mutató pointert Egy olyan új H kupacot készít és ad vissza, amelyik a H 1 és H 2 minden csúcsát tartalmazza. H 1 és H 2 megsemmisül A H kupac x csúcsához az új k kulcs-értéket rendeli hozzá, feltéve, hogy ez az érték nem nagyobb, mint az eredeti. A H kupacból az x csúcsot törli. A binomiális kupac ábrázolásakor a kupacban szereplő fákat a gyökércsúcs fokszáma szerinti növekedő sorrendnek megfelelően soroljuk fel. A gyökércsúcsokat egy listára fűzzük fel, melynek a kezdetére egy fejelem mutató mutat. Fejelem[H] Kirészletezzük az egyes csúcspontok mezőit is. Minden csúcspontban az alábbi kísérő információkat tároljuk. Szülő mutató Kulcs Fokszám

20 Adatstruktúrák, algoritmusok Bal gyerek mutató Az előző ábra ezen információkkal kirészletezve: Jobb testvér mutató Fejelem[H] Pszeudokódok a műveletekre algoritmus Binomiális kupac készítése T // ( n) = Θ(1) 1 BINOMIÁLIS_KUPACOT_KÉSZÍT( H ) 2 // Output paraméter: H az üres új binomiális kupac 3 // 4 fejelem[h] NIL 5 RETURN ( H ) algoritmus Binomiális kupacban minimumkeresés T n = Θ log n // ( ) ( ) 1 BINOMIÁLIS_KUPACBAN_MIN( H, min ) 2 // Input paraméter: H a binomiális kupac 3 // Output paraméter: min mutató a minimális elemre

21 Adatstruktúrák, algoritmusok // 5 min NIL 6 x fejelem[h] 7 minkulcs 8 WHILE x NIL DO 9 IF kulcs[ x ] < minkulcs 1 THEN minkulcs kulcs[ x ] 11 min x 12 x testvér[ x ] RETURN ( min ) algoritmus Binomiális fák összekapcsolása T n ) // ( ) = Θ(1 1 BINOMIÁLIS_ÖSSZEKAPCSOLÁS ( y, z ) 2 // Két B k-1 y és z gyökércsúcsú fát összekapcsol 3 // Input paraméter: y az első fa gyökérmutatója 4 // z a második fa gyökérmutatója 5 // Output paraméter: z az eredményfa gyökérmutatója 6 // 7 szülő[ y ] z 8 testvér[ y ] gyerek[ z ] 9 gyerek[ z ] y 1 INC ( fokszám[ z ] ) 11 RETURN ( z ) // algoritmus Binomiális kupacok egyesítése T ( n) = Θ( logn) 1 BINOMIÁLIS_KUPACOKAT_EGYESIT ( H 1, H 2, H ) 3 // Input paraméter: H 1 az első kupac 4 // H 2 a második kupac 5 // Output paraméter: H az eredmény kupac 6 // 7 // A kupacok gyökércsúcsainak listáit összefésüli növekvő fokszám szerint. Minden fokszámhoz legfeljebb két gyökércsúcs tartozhat. Ezután az azonos fokszámúakat összekapcsolja egy magasabb fokszámúvá. Átmenetileg előfordulhat, hogy azonos fokszámmal három gyökércsúcs is rendelkezik. Ilyenkor az összekapcsolást az utolsó kettőre kell elvégezni. 8 RETURN ( H ) // algoritmus Binomiális kupacba beszúrás T ( n) = Θ( logn) 1 BINOMIÁLIS_KUPACBA_BESZÚR ( H, x )

22 Adatstruktúrák, algoritmusok // Input paraméter: H 1 a kupac 4 // x beszúrandó elem mutatöja 5 // Output paraméter: H a megváltozott kupac 6 // 7 // Létrehozunk egy egy csúcsból álló új binomiális kupacot, amely a beszúrandó csúcsot tartalmazza. Az új és a régi kupacot egyesítjük. ( algoritmussal.) 8 RETURN ( H ) // algoritmus Binomiális kupacból minimum kivágása T ( n) = Θ( logn) 1 BINOMIÁLIS_KUPACBÓL_MINIMUMOT_KIVÁG ( H ) 2 // Input paraméter: H a kupac 3 // Output paraméter: H a megváltozott kupac 4 // 5 // Megkeressük a gyökérlánc minimális elemét. A minimális elem fáját a gyökérlistából kiláncoljuk. A minimális elem gyerekeinek listáját megfordítjuk és létrehozunk egy binomiális kupacot, amelynek ez lesz a gyökérlistája. A két kupacot egyesítjük. 6 RETURN ( H ) // algoritmus Binomiális kupacban kulcsérték csökkentése T ( n) = Θ( logn) 1 BINOMIÁLIS_KUPACBAN_KULCSOT_CSÖKKENT ( H, x, k ) 2 // Input paraméter: H a kupac 3 // x mutató a csökkentendő kulcsú elemre 4 // k az új kulcsérték 5 // Output paraméter: H a megváltozott kupac 6 // 7 // A csökkentett kulccsal az elemet a fájában mindaddig felfelé buborékoltatjuk cserékkel, amíg a kupac tulajdonság nem teljesül. Az elem eljuthat akár a gyökérlistáig is. 8 RETURN ( H ) algoritmus Binomiális kupacból törlés // T ( n) = Θ( logn) 1 INOMIÁLIS_KUPACBÓL_TÖRÖL ( H, x ) B 2 // Input paraméter: H a kupac 3 // x mutató a törlendő elemre 4 // Output paraméter: H a megváltozott kupac 5 // 6 BINOMIÁLIS_KUPACBAN_KULCSOT_CSÖKKENT( H, x, - ) 7 BINOMIÁLIS_KUPACBÓL_MINIMUMOT_KIVÁG( H ) 7 RETURN ( H )