Kiválasztás kupaccal A bináris kupac egy majdnem teljes bináris fa, amely minden szintjén teljesen kitöltött kivéve a legalacsonyabb szintet, ahol balról jobbra haladva egy adott csúcsig vannak elemek. A fát egy tömbben reprezentáljuk, minden elem a szint szerinti bejárás szerinti sorszámának megfelelő eleme a tömbnek. A kupacot reprezentáló A tömbhöz két értéket rendelünk, hossz(a) a tömb mérete, kupacmeret(a) a kupac elemeinek a száma. A kupac gyökere A[1], a szerkezeti kapcsolatok egyszerűen számolhatóak: A[i] bal fia A[2i] A[i] jobb fia A[2i + 1] A[i] apja A[ i/2 ] A kupac minden gyökértől különböző elemére teljesül, hogy az értéke nem lehet nagyobb, mint az apjáé. Ennek következménye, hogy a kupac minden részfájára teljesül, hogy a gyökéreleme maximális. MAXIMUM-KUPACOL Eljárás A MAXIMUM-KUPACOL eljárás helyreállítja az A[i] elemre a kupactulajdonságot. Az elemet süllyeszti cserékkel mindaddig, amíg a tulajdonság sérül. MAXIMUM-KUPACOL(A,i) l:=2i //az A[i] elem bal fiának indexe r:=2i+1 //az A[i] elem jobb fiának indexe if l<=kupacmeret(a) and A[l]>A[i] then max:=l else max:=i if r<=kupacmeret(a) and A[r]>A[max] then max:=r // A[max] a három elem közül a legnagyobb if max!=i then {Csere(A[i],A[max]) MAXIMUM-KUPACOL(A,max)} A=[5,14,13,8,3,4,6,2] MAXIMUM-KUPACOL(A,1) A=[14,5,13,8,3,4,6,2] A=[14,8,13,5,3,4,6,2] Példa Kiválasztás kupaccal Az algoritmus során a for ciklus j értékkel való végrehajtása után a kupac az első j elemből az i legkisebbet tartalmazza. Kupacvalaszt(A,i) Kupacmeret(A):=i for j= [i/2] to 1 MAXIMUM KUPACOL(A,j) // az elso i elembol egy kupac 1
5 14 13 8 3 4 6 14 5 13 2 8 3 4 6 2 14 8 13 5 3 4 6 2 1. ábra. for j=i+1 to n {if A[1]>A[j] then {Csere(A[1],A[j]) MAXIMUM KUPACOL(A,1)}} return A[1] Futási idő: O(i) + (n i)o(logi) Példa A=[2,5,7,3,6,4,8], k=3 A=[2,5,7 3,6,4,8] A=[7,5,2 3,6,4,8] A=[3,5,2 7,6,4,8] A=[5,3,2 7,6,4,8] A=[4,3,2 7,6,5,8] Minimum és maximum egyidejű választása A feladat adott n méretű tömb elemeiből kiválasztani a maximális és minimális elemet. MaxMin(A) if (n%2=0) then {k:=2 if (A[1]<A[2]) then {mini:=1 maxi:=2} else {mini:=2 maxi:=1}} else {k:=1 mini:=1 maxi:=1} 2
while(k<n) {if A[k+1]<A[k+2] then {if A[k+1]<A[mini] then mini:=k+1 if A[k+2]>A[maxi] then maxi:=k+2} else {if A[k+2]<A[mini] then mini:=k+2 if A[k+1]>A[maxi] then maxi:=k+1} k:=k+2} Futási idő Az algoritmus legfeljebb 3n/2 összehasonlítást végez. Bináris keresőfák Az F = (M,R,Adat) absztrakt adatszerkezetet bináris keresőfának nevezzük, ha F bináris fa, R = {bal, jobb, apa}, bal, jobb, apa : M M, Adat : M Elemtip és Elemtip-on értelmezett egy lineáris rendezési reláció, ( x M)( p F bal(x) )( q F jobb(x) )(kulcs(p) kulcs(x) kulcs(q)) InorderBejaras(F,M) if F!=Nil then {InorderBejaras(bal(F),M) M(F) InorderBejaras(jobb(F),M)} Az InorderBejaras algoritmus a bináris keresőfa elemeit a kulcsok rendezés szerinti sorrendjében látogatja meg. Adott kulcsú elem keresése KERES(F,k) if F=Nil or k=kulcs(f) then return F If k< kulcs(f) then return KERES(bal(F),k) else return KERES(jobb(F),k) KERES2(F,k) while(f!=nil and k!=kulcs(f)) {if k<kulcs(f) then F:=bal(F) else F:=jobb(F)} return F Futási idő: A fa magasságával arányos. Minimális maximális elem keresése 3
13 6 23 > 3 9 28 8 <= 2. ábra. FabanMinimum(F) while(bal(f)!=nil) F:=bal(F) return F FabanMaximum(F) while(jobb(f)!=nil) F:=jobb(F) return F Futási idő: A fa magasságával arányos. Rákövetkező, megelőző elem keresése FabanKovetkezo(p) if jobb(p)!=nil then return FabanMinimum(jobb(p)) q:=apa(p) while(q!=nil and p=jobb(q)) {p:=q q:=apa(q)} return q 4
FabanMegelozo(p) if bal(p)!=nil then return FabanMaximum(bal(p)) q:=apa(p) while(q!=nil and p=bal(q)) {p:=q q:=apa(q)} return q Futási idő: A fa magasságával arányos. Beszúrás bináris keresőfába A fát a gyökérpontja által adtuk meg. Beszur(F,z) y:=nil x:=f while(x!=nil) {y:=x if kulcs(z)<kulcs(x) then x:=bal(x) else x:=jobb(x)} apa(z):=y if y=nil then F:=z //Üres volt a fa else {if kulcs(z)<kulcs(y) then bal(y):=z else jobb(y):=z} Futási idő: A fa magasságával arányos. Törlés bináris keresőfából FabolTorol(F,z) If bal(z)=nil or jobb(z)=nil then y:=z else y:=fabankovetkezo(z) If bal(y)!=nil then x:=bal(y) else x:=jobb(y) If x!=nil then apa(x):=apa(y) If apa(y)=nil then F:=x else {if y=bal(apa(y)) then bal(apa(y)):=x else jobb(apa(y)):=x} If y!=z then kulcs(z):=kulcs(y) 5
13 6 23 > 3 9 28 8 11 3. ábra. 13 8 23 > 3 9 28 > 11 4. ábra. 6
Keresőfák magassága Példa: Ha az 1,2,...,n sorrendben szúrunk pontokat egy üres fába a magasság n lesz. Tétel Az n csúcsból álló véletlen építésű bináris fák magassága O(logn). Kiegyensúlyozott bináris keresőfák magassága O(logn) piros fekete fa AVL fa önszervező bináris keresőfák (splay fák) Optimális bináris keresőfa építése Tegyük fel, hogy ismerjük minden a fában szereplő k i kulcsra a keresésének gyakoriságát, ami p i (i = 1,...,n). Továbbá adott minden i-re a k i és k i+1 közés eső sikertelen keresések gyakorisága q 0,q 1,...,q n. Értelemszerűen q 0 a k 1 -nél kisebb, q n a k n -nél nagyobb kulcsok gyakorisága. Ha felépítünk egy F bináris keresőfát x 1,...,x n pontokkal, akkor egy sikeres keresés költsége a gyakoriság szorozva a pont mélységével. A sikertelen keresésekhez hozzárendelhetünk új y i pontokat, ahol a keresés kilép a fából. Ekkor az F fára a várható keresési költség C(F) = n n p i d F (x i ) + q j d F (y j ). i=1 j=0 a cél azon fa megkonstruálása, amelyre ez az összeg minimális. Rekurzív összefüggés Tegyük fel, hogy van egy optimális F keresőfa a k 1,...,k n kulcsokból, aminek x r a gyökere. Ekkor a baloldali részfa F 1 a k 1,...,k r 1 kulcsokból álló bináris keresőfa, a jobboldali részfa F 2 pedig a k r+1,...,k n csúcsokból áll. Nyilván mindkettő optimális kell legyen, különben lecserélve őket F helyett is jobbat kapnánk. Könnyen igazolható, hogy C(F) = C(F 1 ) +C(F 2 ) + n i=1 p i + n q j. j=0 Részproblémák: Minden 0 i j n-re legyen OPT (i, j) az optimális bináris keresőfa költsége a p i+1,..., p j sikeres és a q i,...,q j sikertelen keresési gyakoriságokkal. OPT (i, j) = j u=i+1 p u + j v=i OPT (i,i) = q i q v + min {OPT (i,r 1) + OPT (r, j)}. i<r j A rekurzív összefüggések alapján a feladat megoldható átlós táblázatkitöltéssel. Kiskérdések Linkiválaszt algoritmus Kupacvalaszt algoritmus 7
bináris keresőfa definíciója keresés bináris keresőfában Szorgalmi feladat Adjunk meg egy eljárást, amely kiválasztja a legkisebb és a második legkisebb elemet n elemből n 1 + logn elempár összehasonlításával. Beküldés: cimreh@inf.u-szeged.hu, Leírás +magyarázat + futási idő elemzés első négy megoldó 8-8 pont a második négy megoldó 5-5 pont A szerzett plusszpontok a vizsga minimumkövetelményébe nem számítanak bele. 8