A (bináris) kupac adatstruktúra

Az előadások a következő témára: "A (bináris) kupac adatstruktúra"— Előadás másolata:

1 A (bináris) kupac adatstruktúra
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 továbbá teljesül a kupac tulajdonság. Kupac attribútumok (feltételezve, hogy a reprezentálás egy egyindexes A tömbbel történik, amelyben a kupacot tároljuk.) 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 A fa gyökere A[1] ( =gyökér[T] ) Az i indexű elem esetén az attribútumok: Szülő(i), Bal(i), Jobb(i) :22:55 ADAT-06

2 A kupac tulajdonság Kupac tulajdonság: A[Szülő(i)]  A[i]
Kupac magasság = a fa magassága = (log n) Példa kupacra és tömbös realizációjára: 16 14 10 8 7 9 3 2 4 1 16 14 10 8 7 9 3 2 4 1 5 6 :22:55 ADAT-06

3 Kupac műveletek - 1 Szülő(i) 1 RETURN( i/2 ) Bal(i) 1 RETURN( 2i )
Jobb(i) 1 RETURN( 2i+1) (l) KUPACOL Eljárás a kupac tulajdonság fenntartására (log n) KUPACOT_ÉPÍT Eljárás, mely tetszőleges adatokból kupacot épít O(n) KUPACRENDEZÉS Eljárás, mely helyben rendez O(n log n) :22:55 ADAT-06

4 Kupac műveletek - 2 KUPACOL(A,i)
Akkor használjuk, ha az i baloldali és jobboldali részfái ugyan  kupacok, de i-ben sérülhet a kupac tulajdonság b Bal(i) j Jobb(i) IF b  Kupac_méret[A] és A[b]>A[i] THEN legnagyobb  b ELSE legnagyobb  i IF j  Kupac_méret[A] és A[j]>A[legnagyobb] THEN legnagyobb  j IF legnagyobb i THEN csere A[i]  A[legnagyobb] KUPACOL(A,legnagyobb) :22:55 ADAT-06

5 Kupac műveletek - 3 KUPACOT_ÉPÍT(A)
Most hossz[A] legyen azonos az elemek számával (n) Kupac_méret[A] hossz[A] FOR i  hossz[A]/2 DOWNTO 1 DO KUPACOL(A, i) KUPACRENDEZÉS(A) FOR i  hossz[A] DOWNTO 2 DO csere A[1] A[i] Kupac_méret[A]  Kupac_méret[A] –1 KUPACOL(A,1) :22:55 ADAT-06

6 Kupac műveletek - 4 KUPACBA_BESZÚR(A,kulcs) INC(Kupac_méret[A])
i  Kupac_méret[A] WHILE i>1 és A[Szülő(i)]<kulcs DO A[i] A[Szülő(i)] i Szülő(i) A[i] kulcs O(log n) KUPACBAN_MAX(A) RETURN( A[1] ) (1) :22:55 ADAT-06

7 Kupac műveletek - 5 KUPACBÓL_KIVESZ_MAX(A) IF Kupac_méret[A]<1
THEN hiba „kupac alulcsordulás” max A[1] A[1] A[Kupac_méret[A]] DEC(Kupac_méret[A]) KUPACOL(A,1) RETURN(max) O(log n) :22:55 ADAT-06

8 Az elsőbbségi sor Az elsőbbségi sor (priority queue) olyan S halmaz, amelynek minden eleméhez egy kulcs értéket rendelünk. Műveletei: BESZÚR(S,x): egy elemet hozzáadunk S-hez. S S  {x} MAXIMUM(S): S legnagyobb kulcsú elemének meghatározása KIVESZ_MAX(S): megadja és törli a maximális kulcsú elemet. Az elsőbbségi sor célszerű realizációja a kupac. :22:55 ADAT-06

9 A Huffmann-kód - 1 Huffmann-kód: Adattömörítési célokat szolgáló eljárás A probléma: Legyen adott egy adatfile, amelyben ismert az egyes adatelemek (pl.: byte-ok) gyakorisága. A feladat olyan kódot találni az adat- elemekre, amely révén a kódolt file hossza rövidebb lesz (a lehető legrövidebb), mint az eredeti hossz volt. Az egyszerűség kedvéért a kódoláshoz használjunk két jelet, a 0 és az 1 jeleket. Az adatelemek kódja lehet fix hosszúságú és változó hosszúságú. A kódot egy kódfával ábrázolhatjuk, amely egy bináris fa, levelei a kódszavak és a kódszó a levélhez vezető útból olvasható ki. Ha balra lépünk, akkor 0, ha jobbra lépünk, akkor 1 íródik a kódszóhoz. A kódnak dekódolhatónak kell lennie. :22:55 ADAT-06

10 A Huffmann-kód - 2 Definíció: 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. Két dekódolható kód ekvivalens, ha a megfelelő kódszavaik hossza megegyezik. Bizonyítható, hogy minden dekódolható kódhoz létezik vele ekvivalens prefix kód. :22:55 ADAT-06

11 A Huffmann-kód - 3 Betű Gyakoriság f(c) Kódszó Fix hossz Változó hossz
45 000 B 13 001 101 C 12 010 100 D 16 011 111 E 9 1101 F 5 1100 :22:55 ADAT-06

12 A Huffmann-kód - 4 100 100 1 1 86 14 55 A:45 1 1 58 28 14 30 25 1 1 1 1 A:45 B:13 C:12 D:16 E:9 F:5 1 C:12 B:13 14 D:16 1 F:5 E:9 :22:55 ADAT-06

13 A Huffmann-kód - 5 A fa költsége:B(T)= f(c)d(c) c C
ahol d(c) a betú mélysége a fában (kódszóhossz) Definíció: Optimális a kód, ha a fa költsége minimális. Az optimális kód bináris fája mindig teljes. A Huffmann-kód optimális. A Huffmann-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 pszeudokód kiindul egy prioritási sorból, amelyben a betűk a gyakoriságaik szerint vannak kulcsolva. Ezután n-1 lépésben a két 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. :22:55 ADAT-06

14 A Huffmann-kód - 6 Az algoritmus 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. (A mohó stratégia elemei: Az adott pillanatban mindig az ott legjobbnak tűnő lehetőséget választjuk a részprobléma megoldására. Ez 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 optimumra.) :22:55 ADAT-06

15 A Huffmann-kód - 7 HUFFMANN( C ) n  C Q  C FOR i  1 TO n-1 DO
z PONTOT_LÉTESÍT() x  Bal[z]  KIVESZ_MIN(Q) y  Jobb[z]  KIVESZ_MIN(Q) f[z]  f[x]+f[y] BESZÚR(Q,z) RETURN( KIVESZ_MIN(Q) ) O(n log n) :22:55 ADAT-06

16 A Huffmann-kód - 8 F:5 E:9 C:12 B:13 D:16 A:45 C:12 B:13 14 D:16 A:45
25 A:45 F:5 E:9 C:12 B:13 :22:55 ADAT-06

17 A Huffmann-kód - 9 25 30 A:45 C:12 B:13 14 D:16 F:5 E:9 55 A:45 25 30
:22:55 ADAT-06

18 A Huffmann-kód – 10 100 A:45 55 25 30 C:12 B:13 14 D:16 F:5 E:9
:22:55 ADAT-06

19 Diszjunkt halmazok A diszjunkt halmazok adatszerkezet dinamikus halmazok S=(S1,S2,…,Sk) együttese. Mindegyik halmazt egy képviselője azonosít, mely eleme a halmaznak. Általában lényegtelen, hogy melyik ez az elem. A halmazok elemei objektumok. Műveletek: 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ó Sx és az y-t tartalmazó Sy 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. :22:55 ADAT-06

20 Diszjunkt halmazok alkalmazása
Megkeressük egy gráf összefüggő komponenseit. ÖSSZEFÜGGŐ_KOMPONENSEK(G) FOR v V[G] csúcsra DO HALMAZT_KÉSZÍT(v) FOR  (u,v) E[G] élre DO IF HALMAZT_KERES(u)  HALMAZT_KERES(v) THEN EGYESÍT(u,v) UGYANAZ_A_KOMPONENS(u,v) IF HALMAZT_KERES(u) = HALMAZT_KERES(v) THEN RETURN(IGAZ) ELSE RETURN(HAMIS) :22:55 ADAT-06

21 Diszjunkt halmazok realizálása - 1
Láncolt listás realizálás a b c d e f g fej fej a b c d e f g fej EGYESIT(a,e) :22:55 ADAT-06

22 Diszjunkt halmazok realizálása - 2
Diszjunkt halmaz erdő (gyökeres fákkal) Gyökér a e Gyökér Gyökér e b d f a f c g b d g c EGYESIT(c,f) :22:55 ADAT-06

23 Programok diszjunkt halmaz erdőkre - 1
HALMAZT_KÉSZÍT(x) Szülő[x] x Rang[x] 0 ÖSSZEKAPCSOL(x,y) IF Rang[x]>Rang[y] THEN Szülő[x] x ELSE Szülő[x] y IF Rang[x]=Rang[y] THEN Rang[y]  Rang[y] +1 :22:55 ADAT-06

24 Programok diszjunkt halmaz erdőkre - 2
HALMAZT_KERES(x) IF x  Szülő[x] THEN Szülő[x] HALMAZT_KERES(Szülő[x]) RETURN(Szülő[x]) EGYESÍT(x,y) ÖSSZEKAPCSOL( HALMAZT_KERES(x), HALMAZT_KERES(y) ) :22:55 ADAT-06