You are on page 1of 2

a Műveletigény: mT(n) ∈ O(nlgn

)
kupac:

Műveletigény: MTIS(n) ∈ Θ(n^2)
beszúró rendezés LL:

MÜ(n) = Ordo (n^2)
AÖ(n) kb MÖ(n)/2 = Ordo(n^2)
mÖ(n)=n-1
prior sorok műveletei:

PrSor
-A[1..n]:T
-m: 0..n
a Műveletigény: O(n lg n) +PrSor() {m:=0} //üres inic prSort //no
láncolt listák destruktor
+prSorba(x) //beteszi x-et a prSorba
+fv maxKives() //kiveszi és visszaadja a prSor
max elemét
+fv max() // megnézi és visszaadja a prSor max
elemét
+fv tele_e(){return m = n}
+fv üres_e(){return m = 0}
merge sort rekurziv: megelőző testvére is a minimumon van, hogy teljesítse az
invariánst, akkor egyesítsük egy vele szomszédos
merge sort tömbre: testvérével; ha a csúcs nem levél, akkor be kell vonnunk a
szülőből a hasító kulcsot a testvérek egyesítésébe. Levél
Bináris keresőfák: vagy nem, mindkét esetben meg kell ismételnünk a törlő
műveletek: FOGALMAK: algoritmust a szülőre, hogy eltávolítsuk a szülőből a hasító
bináris fák: kulcsot, ami eddig elválasztotta a most egyesített
• Szigorúan bináris fa: Azokat a bináris fákat, amelyekben csúcsokat — kivéve, ha a szülő a gyökércsúcs, és az utolsó
minden belső (azaz nem-levél) csúcsnak két gyereke van, kulcsa az eltávolítandó hasító kulcs, amikor is a most
szigorúan bináris fáknak nevezzük egyesített csúcs lesz az új gyökér (és a fa egy szinttel
• Teljes bináris fa: Ha ez utóbbiaknak min-den levele alacsonyabb lesz, mint a törlés előtt volt).
azonos szinten van, teljes bináris fákról beszélünk • Tulajdonságok:
• Majdnem teljes: Ha egy teljes bináris fa levélszintjéről o Minden levélben legfeljebb d-1 kulcs, és ugyanennyi, a
nulla, egy vagy több levelet elveszünk, de nem az összeset, megfelelő (azaz ilyen kulcsú) adatrekordra hivatkozó
az eredményt majdnem teljes bináris fának ne-vezzük mutató található. A gyökértől mindegyik levél ugyanolyan
• Méret szerint kiegyensúlyozott: Egy bináris fa méret távol található. (Más szavakkal, minden levél azonos
szerint kiegyensúlyozott, ha tetszőleges nemüres részfája mélységben, a legalsó szinten van.)
bal és jobb részfájának mérete legfeljebb eggyel térhet el. o Minden belső csúcsban eggyel több mutató van, mint
• Magasság szerint kiegyensúlyozott: Egy bináris fa kulcs, ahol d a felső határ a mutatók számára. Minden Cs
magasság szerint kiegyensúlyozott, ha minden csúcsa belső csúcsra, ahol k a Cs csúcsban a kulcsok száma: az
kiegyensúlyozott első gyerekhez tartozó részfában minden kulcs kisebb, mint
• Balra tömörített: Egy majdnem teljes bináris fa balra a Cs első kulcsa; az utolsó gyerekhez tartozó részfában
tömörített, ha az alsó szintjén egyetlen levéltől balra sem minden kulcs nagyobb-egyenlő, mint a Cs utolsó kulcsa; és
lehet új levelet beszúrni az i-edik gyerekhez tartozó részfában (2 ≤ i ≤ k) lévő
kupacok: tetszőleges r kulcsra Cs.kulcs[i-1] ≤ r < Cs.kulcs[i].
• Maximum-kupac: Egy balra tömörített, majdnem teljes o A gyökércsúcsnak legalább két gyereke van (kivéve, ha
bináris fát maximum-kupacnak (heap) nevezünk, ha ez a fa egyetlen csúcsa, következésképpen az egyetlen
minden belső csúcs kulcsa nagyobb-egyenlő, mint a levele is). Minden, a gyökértől különböző belső csúcsnak
gyerekeié. legalább floor(d / 2) gyereke van. (floor(d / 2) = d/2 alsó
• Minimum-kupac: Ha minden belső csúcs kulcsa kisebb- egész-rész.)
egyenlő, mint a gyerekeié, minimum- kupacról beszélünk o Minden levél legalább floor(d / 2) kulcsot tartalmaz
AVL fák műveletei: • Lyukas kupac: Egy balra tömörített, majdnem teljes (kivéve, ha a fának egyetlen csúcsa van). A B+ fa által
bináris fát lyukas kupacnak nevezünk, ha a fa egyik csúcsa reprezentált adathalmaz minden kulcsa megjelenik
a lyuk, és minden szülő-gyerek párosban a szülő kulcsa valamelyik levélben, balról jobbra szigorúan monoton
nagyobb-egyenlő, mint a gyereke kulcsa, kivéve, ha a páros növekvő sorrendben.
egyik tagja maga a lyuk. A lyuk kulcsa nemde niált, de ha a Programok műveletigénye:
lyuknak van szülője, akkor annak kulcsa ≥ mint a lyuk
leszármazottainak kulcsa
• Csonka kupac: Egy balra tömörített, majdnem teljes
bináris fát csonka kupacnak nevezünk, ha minden szülő-
gyerek párosban a szülő kulcsa nagyobb-egyenlő, mint a
gyereke kulcsa, kivéve, ha a szülő a gyökércsúcs. A
gyökércsúcs kulcsa is de niált, de lehet, hogy kisebb, mint a
gyereke kulcsa
biniáris keresőfák:
• Fogalom: Egy bináris fát keresőfának nevezünk, ha
minden nemüres r részfájára és annak a gyökerében lévő y
kulcsra igazak az alábbi követelmények:
- Ha x egy tetszőleges csúcs kulcsa az r bal részfájából,
akkor x < y.
- Ha z egy tetszőleges csúcs kulcsa az r jobb részfájából,
akkor z > y.
AVL fák:
• Fogalom: Az AVL fák magasság szerint kiegyensúlyozott
bináris keresőfák.
• Magassága: ⌊lgn⌋ ≤ h ≤ 1,45lgn, azaz h ∈ Θ(lgn)
• Kiegyensúlyozás: AVL tree balancig:
- ha a bal oldali részfa magasabb 1-el
+ ha a job oldali magasabb 1-el
++ ha 2-vel magassabb a jobb
-- ha 2-vel magasabb a bal
= ha egyenlő
B+ fák:
• Definició: B+ fa, amiben minden csúcs legfeljebb d
mutatót (4 ≤ d), és legfeljebb d-1 kulcsot tartalmaz. Úgy
Bellman ford alg: tekintjük, hogy a belső csúcsokban mindegyik referencia
két kulcs "között" van, azaz egy olyan részfa gyökerére
mutat, amiben minden érték a két kulcs között található
(mindegyik csúcshoz hozzáképzelve balról egy "mínusz
végtelen", jobbról egy "plusz végtelen" értékű kulcsot).
beszúrás algoritmus:
1. Ha a csúcsban van üres hely, szúrjuk be a megfelelő
adat/mutató párt kulcs szerint rendezetten ebbe a csúcsba!
2. Ha a csúcs már tele van, vágjuk szét két csúccsá, és
osszuk el a d darab kulcsot egyenlően a két csúcs között!
Ha a csúcs egy levél, vegyük a második csúcs legkisebb
értékének másolatát, és ismételjük meg ezt a beszúró
algoritmust, hogy beszúrjuk azt a szülő csúcsba! Ha a csúcs
nem levél, vegyük ki a középső értéket a kulcsok elosztása
során, és ismételjük meg ezt a beszúró algoritmust, hogy
beszúrjuk ezt a középső értéket a szülő csúcsba! (Ha kell, a
szülő csúcsot előbb létrehozzuk.)
törlés algoritmus:
1.Töröljük a megfelelő kulcsot és a hozzá tartozó mutatót
a csúcsból!
2. Ha a csúcs még tartalmaz elég kulcsot és mutatót,
hogy teljesítse az invariánsokat, kész vagyunk.
3.Ha a csúcsban már túl kevés kulcs van ahhoz, hogy
teljesítse az invariánsokat, de a következő, vagy a
merge sort: megelőző testvérének több van, mint amennyi szükséges,
osszuk el a kulcsokat közte és a megfelelő testvére között!
Merge(S1, S2, Javítsuk ki a testvérek szülőjében a két testvérhez tartozó
S3 S3)
:= E hasító kulcsot úgy, hogy megfelelően reprezentálja a
S1 /= E && S2 /= E köztük megváltozott vágási pontot! Ennek során csak a
S1.lov<S2.lov S1.lov=S2.lov S1.lov>S2.lov közös szülőjükben lévő, a testvérekhez tartozó hasító
S3:hiext(S1.lov kulcsot kell átírni, törlés vagy beszúrás nélkül.
S3:hiext(S1.lo ) S3:hiext(S2.lo 4. Ha a csúcsban már túl kevés kulcs van ahhoz, hogy
teljesítse az invariánst, és a következő, valamint a
v) S3:hiext(S2.lov v)
)
lorem(S1) lorem(S1) lorem(S2)
lorem(S2)

S3:=<S3, S1, S2>

Merge(S)

|S|<=1
Merge(A, k, l)
Szétvág(S, S1, S2)
S k>=l
MergeSort(S1)
K  k l
MergeSort(S2)
SI  2 
K
P Merge(S1, S2, S)
I h:=
P MergeSort(A, k, h)
MergeSort(A, h+1, l)
Merge(A[k..h], A[h+1..l], A[k..l])