Anda di halaman 1dari 95

Adatstruktrk

Kirly Zoltn
2.55 verzi
2014. jlius 3.

Legfrissebb, on-line verzi:


http://www.cs.elte.hu/~kiraly/Adatstrukturak.pdf

Elekes Gyrgy emlkre

Tartalomjegyzk
1. Alapvet adatszerkezetek
1.1. Adatstruktrk tervezse
1.2. Lncolt lista . . . . . . .
1.3. Sor s verem . . . . . . .
1.4. Grfok . . . . . . . . . .

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

.
.
.
.

2. Grfok bejrsa: szlessgi keress


2.1. sszefgg-e a grf? . . . . . . . . . .
2.2. Grfok komponenseinek meghatrozsa
2.3. Legrvidebb utak . . . . . . . . . . . .
2.4. Ktsznezhetsg . . . . . . . . . . . .
2.5. Irnytott grfok . . . . . . . . . . . .

.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.

.
.
.
.
.

.
.
.
.

4
4
4
5
6

.
.
.
.
.

11
12
12
12
15
15

3. (Binris) Kupac

16

4. Minimlis kltsg fesztfa, legrvidebb t keresse


4.1. Kruskal algoritmusa . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2. DISZJUNKT-UNIHOLVAN adatstruktrk . . . . . . . . . . . .
4.3. Prim algoritmusa . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.4. Dijkstra algoritmusa . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5. d-edfok kupacok . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5.1. A Dijkstra s Prim algoritmus lpsszma d-edfok kupaccal

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

20
20
22
29
30
32
33

5. Amortizcis elemzs
34
5.1. Potencil s amortizcis id . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5.1.1. Amortizcis id s a strigulzs kapcsolata . . . . . . . . . . . . . 35
5.2. Konvex burok keresse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
6. Fejlettebb kupacok
6.1. Fibonacci kupac . . . . . . . . . . . . . . . . . .
6.1.1. Szigor Fibonacci-kupac . . . . . . . . .
6.2. Prosts kupacok . . . . . . . . . . . . . . . . .
6.2.1. A prosts kupacok hatkony vltozata
6.2.2. A prosts kupacok legjabb vltozatai
6.3. r-kupacok . . . . . . . . . . . . . . . . . . . . .
6.4. Thorup kupaca . . . . . . . . . . . . . . . . . .
7. Sztrak
7.1. Binris keresfa . . . . . . . . . . . . . . . . . .
7.1.1. Mveletek ltalnos binris keresfban .
7.1.2. Optimlis binris keresfa . . . . . . . .
7.2. 2-3 fk . . . . . . . . . . . . . . . . . . . . . . .
7.3. B-fk . . . . . . . . . . . . . . . . . . . . . . . .
7.4. Piros-fekete fk . . . . . . . . . . . . . . . . . .
3

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.

36
37
42
42
45
45
46
49

.
.
.
.
.
.

49
51
52
54
55
58
58

7.5. AVL-fk (Adelszon-Velszkij s Landisz) . . . . . . . . . . . . . . . . . . . . 62


7.6. nkiegyenslyoz fk (Splay-tree; Sleator s Tarjan) . . . . . . . . . . . . . 63
8. Hash-els
8.1. Klasszikus hash fggvnyek . . . . . .
8.2. tkzsek feloldsa . . . . . . . . . . .
8.2.1. Lncolt (vdrs) hash-els . . .
8.3. Nylt cmzs . . . . . . . . . . . . . . .
8.4. Lineris hash-els . . . . . . . . . . . .
8.5. Dupla hash-els . . . . . . . . . . . . .
8.6. A dupla hash-els Brent-fle vltozata .
8.7. Univerzlis hash-els . . . . . . . . . .
8.8. Egyenletes hash-els . . . . . . . . . .
8.9. Tkletes hash-els . . . . . . . . . . .
8.9.1. Dinamikus tkletes hash-els .

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.

67
67
68
68
70
71
72
73
73
74
75
76

9. A van Emde Boas struktra


77
9.1. Trhely, megvalsts, javts . . . . . . . . . . . . . . . . . . . . . . . . . 79
10.Az LCA feladat
80
10.1. A 1-RMQ feladat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
10.2. ltalnos RMQ feladat visszavezetse az LCA feladatra . . . . . . . . . . . 83
11.Geometriai adatstruktrk
11.1. Egy dimenzis feladatok . . . . . . . . . . . . . . . . .
11.2. Kt dimenzis feladatok . . . . . . . . . . . . . . . . .
11.2.1. Javts Kaszkd trolssal . . . . . . . . . . . .
11.3. Egy tglalapot metsz szakaszok lekrdezse . . . . . .
11.3.1. Kupacos keresfk . . . . . . . . . . . . . . . .
11.4. Ferde szakaszok lekrdezse . . . . . . . . . . . . . . .
11.4.1. Szakasz-fa . . . . . . . . . . . . . . . . . . . . .
11.4.2. Egy fggleges szakaszt metsz ferde szakaszok

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.

84
84
86
88
88
89
92
92
93

1. Alapvet adatszerkezetek
1.1. Adatstruktrk tervezse
A programozsi feladatok megoldsa sorn elszr az algoritmus vzlatt ksztjk el,
majd a szksges adatstruktrk defincijt: milyen objektumokat akarunk trolni, s
ezekkel milyen mveleteket akarunk vgezni.
Specifikci:

Milyen objektumokat akarunk trolni


Milyen mveleteket akarunk vgezni ezeken az objektumokon, ezek a mveletek
ltalban:
o res adatstruktra ltrehozsa
o Elem beraksa az adatstruktrba
o Specilis mveletek (pld. keress, a legkisebb kulcs elem kivtele)

Ezutn az algoritmust fokozatosan pontostjuk, egyre rszletesebben kidolgozzuk. A


finomtsok sorn ksztjk el az eljrsokat, amelyek ellltsa sorn a fenti lpsek
ismtldnek meg. Ehhez hasonl mdon definiljuk s finomtjuk az adatstruktrkat
is. Elssorban az fogja meghatrozni, hogy milyen megvalstst vlasztunk, hogy milyen adatokat akarunk trolni az adott adatstruktrban s milyen mveleteket akarunk
vgezni rajtuk.
A tervezs fontos rsze az elemzs: minden mvelethez kiszmoljuk a vgrehajtsi
idejt, s ennek segtsgvel az egsz algoritmus lpsszmt. Igyeksznk az algoritmus
ltal gyakrabban hasznlt mveletek idejt cskkenteni.
ltalban nincs univerzlisan legjobb adatstruktra, a felhasznls hatrozza meg,
hogy melyik lesz a legmegfelelbb (pld.: nem felttlenl az az adatstruktra lesz a legjobb, amelyben a leglassabb mvelet elvgzsnek ideje minimlis). Azt a megvalstst
rdemes vlasztani, ahol az algoritmus ltal leggyakrabban hasznlt mveletek a leggyorsabban valsthatk meg. Tovbb, termszetesen, a gyakorlatban nem mindig az az
adatstruktra a leghatkonyabb, aminek az elmleti futsi ideje a legjobb, az elads
sorn helyenknt ki fogunk trni az ilyen meggondolsokra is.
Ha rendelkezsnkre ll mr egy j adatstruktra, akkor akr az is elfordulhat, hogy
rdemesebb az algoritmuson vltoztatni.
A gyakorlatban sokszor sszetett (egymssal kapcsold) adatstruktrkat hasznlunk, ilyenekre is fogunk pldkat mutatni.

1.2. Lncolt lista


Tulajdonsgai:

A lista egy listafejbl s tetszleges szm listaelembl ll.


Az elemek a memriban sztszrtan helyezkedhetnek el.
Minden elem kt rszbl ll: egy, az adatot, vagy adatokat tartalmaz adat-rszbl,
valamint egy mutatbl (pointerbl ), amely a kvetkez elem memriacmt tartalmazza.
5

A lista els elemre a listafej mutat, a lista utols elemnek mutatja pedig nem
mutat sehov (nil mutat).

Listval ltalban a kvetkez mveleteket akarjuk elvgezni: res-e?, els elem, kvetkez elem (alapmveletek). Ezen kvl: elem keresse, elem beszrsa, elem trlse. A
lpsszm az elemi mveleteknl O(1), a tbbinl ltalban O(l), ahol l a lista hossza, de
pld. az ppen megtallt elem trlse O(1) lps, s a lista elejre val beszrs (ha eltte
nem kell keresni) is O(1) lps.
Ksbb fogunk egyb lncolt lista vltozatokkal is tallkozni, pld.

nha rdemes a lista utols elemre mutat pointert is fenntartani,


nha rdemes a listban kulcs szerint rendezve trolni az elemeket,
sokszor hasznos ktszeresen lncolt lista, ahol egy listaelemhez kt pointer tartozik,
az egyik a kvetkez, a msik a megelz listaelemre mutat,
vagy ciklikusan lncolt lista, ahol az utols elem pointere nem nil, hanem a legels
elemre mutat,
illetve ezek kombincija.

listafej
nil

Hzi feladat: Lncolt listban a keress lpsszma legrosszabb esetben a lista hossza.
A beszrs 1 lps, ha tudjuk, hogy nincs benne; s a lista hossza, ha eltte ellenrizni
kell. A trls lpsszma a lista hossza; kivve, ha a lista ktszeresen lncolt s hvskor
a trlend elemre mutat pointert kaptunk, ekkor O(1) lps.

1.3. Sor s verem


Tulajdonsgai:

Tetszleges tpus objektumok trolsra alkalmas.


Ha egy sorbl kivesznk egy elemet, akkor a legrgebben berakott elemet kapjuk
vissza. A verem abban klnbzik a sortl, hogy elem-kivtel esetn az utolsnak
berakottat kapjuk vissza.
Mveletek:

j, res sor ltrehozsa (S nvvel n mrett): jsor(S, n)


Nem-res-e a sor? : S 6=?
j elem beraksa a sorba: S v
Elem kivtele a sorbl : u S
6

Mveletek megvalstsa: Cl, hogy konstans idben el tudjunk vgezni minden


mveletet.
A sor mrett meghatroz n rtk lehet ismeretlen, ekkor nem tudunk jobbat, mint hogy
a sort lncolt listban troljuk listavg pointerrel (br az STL knyvtrban pl. vannak vltoz hosszsg tmbk, de inkbb csak egy knyelmi szolgltats, nem konstans, hanem
hosszban lineris lpsszmokkal). Ha ismernk valami fels becslst a sor mretre,
akkor jobbat is tudunk:
1. Ha n fels becsls az S v mveletek szmra:
ELEJE,VGE: pointer

ST

1
3 6 1

ELEJE
VGE

jsor(S, n):
jtmb(ST,n)
ELEJE:=1; VGE:=0
S 6=?:

ELEJE VGE

S v:
VGE++
ST(VGE):=v
u S:
u:=ST(ELEJE)
ELEJE++
2. Ha csak egy n |S| fels becslst tudunk:
n + 1 mret tmbben ciklikusan oldjuk meg a mveleteket.
Hzi feladat: rjuk meg ezt a vltozatot.
A verem megvalstsa hasonl, itt a msodik eset is knnyen megvalsthat s nem
kell az ELEJE mutat (mivel mindig 1).

1.4. Grfok
Cl: adatstruktra egy V = {1, 2, . . . n} cscshalmaz m l grf trolsra. (Ha a
grfunk nem ilyen mdon adott, akkor feltesszk, hogy ltezik egy olyan jl szmolhat
bijektv fggvnynk, ami ilyen cscshalmazv szmozza t a grf cscsait. Ezen kvl
vagy jl szmolhat az inverze, vagy azt egy n hossz tmbben troljuk.)
7

1. Szomszdsgi mtrix: n n-es A = {ai,j } mtrixban troljuk az leket:



1 ha ij E
ai,j =
0 ha ij
/E
Ha a grf irnytatlan, akkor a mtrix szimmetrikus lesz. Ekkor a ftl feletti rszt
elg (lenne) trolni.
Trhely: n2 bit (kevs programnyelv tmogatja a bit mtrixot, radsul hasznlatuk
sokszor lassabb, ezrt a gyakorlatban n2 rvid egszet (vagy char tpust) hasznlunk,
legalbbis ha belefr a memriba).
Mveletek:

j (csupa-0) mtrix ltrehozsa: O(n2 ),


ij ?E: ez itt 1 lpsben megy,
Adott u cscsbl kimen lek felsorolsa: for uv E . . .
Vgigmegynk a mtrix u-adik sorn, ez O(n) lps.
A grf egy lnek behzsa vagy trlse: ai,j := 1 vagy ai,j := 0.

Megjegyzs: Multigrf (olyan grf, amelyben lehetnek huroklek is, s a cscsok kzt tbb prhuzamos l is mehet) esetn:
ai,j = k, ha i-bl j-be k db prhuzamos l megy
ai,i = 2k, ha az i-edik cscson k darab hurokl van (gy az i-edik sor sszege tovbbra is a
cscs fokszma lesz).

Slyozott egyszer grfok :


Kt esetet klnbztetnk meg:
A 0 sly nem megengedett: Ebben az esetben nincs problma: a 0 rtk azt jelenti,
hogy a kt cscs kzt nem megy l, a nem nulla rtk pedig a kt cscsot sszekt
l slyt jelenti.
A 0 sly is megengedett: Ekkor tbb informcira van szksgnk: ismernnk kell
pldul a legkisebb slyt. (Ha pldul a slyok nemnegatvak, akkor 1 jelentheti
azt, hogy az adott cscsok kzt nem megy l.)
Tbbfle sly is tartozik egy lhez: tbb mtrixot hasznlunk.
Megjegyzs: Ekkor persze a tr sly-tpusonknt n2 log U , ahol U a max sly.
Megjegyzs: Slyozott multigrfokat gy nem tudunk trolni.

2. llista: Egy L[1 : n] tmbben troljuk a cscsokbl kiindul leket felsorol lncolt
listk listafejeit.

L
1

nil

n
LISTAFEJEK

Az i. cscsbl legalbb 3 l megy ki: pld. a 2-es,. . . , az 5-s s a 8-as szm cscsba.
Trhely: n+m mutat (irnytatlan esetben n+2m, mivel minden l ktszer szerepel)
s m (ill. 2m) szm.
Mveletek :

res struktra ltrehozsa: A listafej-tmbt ltrehozzuk s nil-ekkel tltjk fel:


O(n).
ij ?E: Legrosszabb esetben vgig kell menni a lncolt listn. Ez d(i) n 1
(egyszer grf esetn, klnben d(i) > n is lehet) lpst jelent. (Irnytott grf
esetn a fels korlt az adott cscsra a dki (i) kifok.)
Adott i cscsbl kimen lek felsorolsa: A lpsszm ebben az esetben is d(i) vagy
dki (i).
j l beszrsa (ij irnytott l beszrsa):
p := L(i); L(i) := beszrt j (j, p) listaelem cme a memriban.
(rdemes mindig a lncolt lista elejre beszrni.) Lpsszm: O(1).
ij l trlse: Az i-edik s a j-edik listban meg kell keresni, ez d(i) + d(j) lps,
utna kitrlni mr konstans.

Megjegyzsek.
Az lfelsorols (ltalban a leggyakrabban hasznlt) mvelet ideje kis fokszm esetn
sokkal jobb, mint a szomszdsgi mtrixnl.

Megfordtott G grf generlsa: vgigmegynk az leken s egy j llistba tmsoljuk


a fordtottjukat, ez O(m) idben megoldhat.

Irnytott grfbl a megfelel irnytatlan G grf generlsa: vgigmegynk az leken s egy j llistba tmsoljuk az leket is s a fordtottjukat is, ez O(m) idben
megoldhat.
Multi- s slyozott grfok esetn: A lncolt listban minden gond nlkl trolhat.
Mivel egy listaelem adatrsze akrhny adatbl llhat, mg az se gond, ha az lekhez
tbb szm (kapacits, sly s hossz) is tartozik.

Irnytatlan grf esetn, ill. irnytottnl, ha a fordtott lekre is szksge van az algoritmusnak, akkor egy uv l szerepel az u cscs s a v cscs llistjn is. Sokszor hasznos
minden listaelembe egy j pointert felvenni, s az ilyen prokat egymsra linkelni. Pl.
ha u listjn megtalltuk az let, s mondjuk a hosszt vltoztatni szeretnnk, akkor
persze a v listjn a prjnak hosszt is vltoztatni kell.
Input formtumknt mg hasznlatos az mlesztett llista: az els sor az n cscsszmot
tartalmazza, utna a grf lei tetszleges sorrendben vannak felsorolva, egy sorban egy l
kezdcscsa s vgcscsa, utna esetleg az adott l slya, hossza, kltsge.
3. Mtrixban trolt llista (egyszer grfokra)
Egy n D mret mtrixot hasznlunk. A mtrix i-edik sorban felsoroljuk az i-edik
cscsbl kiindul lek vgpontjait. Ha k darab l megy ki, akkor a mtrix i-edik sorban
a k + 1-edik oszloptl a D-edik oszlopig nullk szerepelnek.
D

i 2 5 8 0 0

Az i. cscsbl 3 l megy ki: a 2-es, az 5-s s a 8-as szm cscsba.


Ha az lek slyozottak, akkor a slyokat egy msik mtrixban troljuk, pld. az i5 l
slyt S(i, 2) tartalmazza.
D megvlasztsa:

Ha a fokszmokrl semmit nem tudunk: D := n.


Ha = maxfok(G) ismert, akkor D := + 1 (azrt rdemes + 1-et vlasztani,
hogy minden sor 0-val vgzdjn, gy az i. cscsbl akkor nem indul ki tbb l, ha
az i. soron lpkedve egy 0-hoz rnk).

Nyeresg: Nem kell pointereket hasznlni.


Vesztesg: A trhely nhetett is. A trhely mrete n (maxfok+1), az n tlagfok
helyett s ez mg a jobbik eset, amikor ismerjk -t. Ha -rl nem tudunk semmit,
akkor n2 hely kell.
Mveletek ideje: Az alapmveleteknl ugyanaz, mint az llista esetn, st, egy kicsit
mg gyorsabb is, mivel nem kell pointerekkel dolgoznunk. A beszrs s a trls lehet
lassabb (ha a beszrs fontos, egy kln tmbben trolhatjuk az els 0 indext).
sszefoglalva: ez a megolds a gyakorlatban egy j megoldsnak tekinthet, ha vagy
ismernk egy n-nl lnyegesen kisebb fels korltot -ra, vagy ha a trfoglals nem nagyon
rdekel minket (hiszen az egy cscsbl kiindul leket itt is fel tudjuk sorolni fokszm
idben).
10

Nem regulris grfokra, ha az algoritmus sorn nem vltoznak, jobban megri az albbi
vltozat: a mtrix sorai vgrl vgjuk le a 0-kat, majd a sorokat fzzk egyms utn egy
T tmbbe. Kzben egy K[1 : n] tmbbe felrjuk, hogy melyik cscs llistja hol kezddik,
azaz K(1) = 1, K(2) = d(1) + 1, K(3) = d(1) + d(2) + 1, . . .. A for uv E . . . ciklus
ekkor gy nz ki: for i = K(u)..K(u + 1) 1 v := T (i); . . . . A trhely pl. irnytott
grfok esetn m + n-re cskkent.
A feladattl fggen sokszor megri, ha az akrmilyen formtumban (pl. szomszdsgi
mtrixban) kapott grfot az algoritmus elejn ilyenn alaktjuk. Fleg, ha a grfnak
lnyegesen kevesebb, mint n2 le van, s radsul egy-egy cscs llistjn az algoritmus
sorn sokszor kell vgigmenni.
Specilis esetek
Pros grfok trolsa szomszdsgi mtrix-szal: elg
sorok s a felsnek megfelel oszlopok).
Fk trolsa:

n2
4

hely (az als halmaznak megfelel

llista
Prfer kd: Egy n cscs grf esetn n 2 darab szm (melyek 1 s n kzttiek).
Ez a trols nagyon alkalmas vletlen fk generlsra (ami egybknt nem egyszer
feladat).
Pointerekkel (gykeres fknl alkalmazzuk, ahol a felfel men let meg akarjuk
klnbztetni a tbbitl; lsd ksbb). Ha a gyerekek szmra nincs j fels korlt,
akkor a cscsban az els gyerekre mutat csak pointer, s a gyerekek egy lncolt
listban vannak.
Kupacoknl (teljesen kiegyenslyozott fk): tmbben.

11

2. Grfok bejrsa: szlessgi keress


Szlessgi keress esetn egy adott pillanatban minden egyes cscs 3 fle llapotban lehet:
a) Az algoritmus sorn eddig mg nem ltott
b) Ltott, de mg nem tvizsglt
c) Ltott s tvizsglt
Egy u cscs tvizsglsa azt jelenti, hogy vgigmegynk a belle kimen leken, s ha
a) tpus cscsot tallunk, azt tsoroljuk b) tpusv; vgl u-t magt pedig c) tpusv.
A szlessgi keressnl a b) llapot cscsok kzl a legrgebbit vizsgljuk t.
Egy L bittmbt (L(i) = 1 ha i-t mr lttuk az algoritmus sorn) s egy S sort (ez
tartalmazza a b) llapot cscsokat) hasznlunk.
Az algoritmus:
INIT:
jsor(S, n); jtmb(L, n)
for i := 1 . . . n L(i) := 0
L(1) := 1; S 1 / ltott, de nem tvizsglt
while S 6=
uS
for uv E
if L(v) = 0 then L(v) := 1; S v
Ez az algoritmus magban nem ad outputot, csak vgigltogatja a grf 1-es cscsbl
elrhet cscsait.
Lpsszm: Egy cscsot maximum egyszer rakunk be a sorba, gy maximum n-szer
tudunk kivenni elemet a sorbl. Amennyiben szomszdsgi mtrixban troljuk a grfot,
akkor a lpsszm O(n2 ).
1. Ttel. Nincs olyan
algoritmus, amely tetszleges, szomszdsgi mtrixszal adott grfrl

kevesebb, mint n2 idben eldnti, hogy sszefgg-e, teht a szlessgi keress lnyegben
optimlis lpsszm szomszdsgi mtrix esetn.
Ezt itt nem bizonytjuk, ellensg-stratgia mdszerrel nem tlsgosan nehz.
llists trols esetn a for ciklus
P d(u)-szor fut le. A futsi idt ekkor nem rdemes
n max d(u)-val becslni, hanem u (1 + d(u)) = n + 2m-mel becsljk. gy a futsi id
O(n + m) lesz, ami izollt cscsot nem tartalmaz grf esetn O(m).
2. Ttel. Ennl lnyegesen gyorsabban llists trolsnl sem valsthat meg a grfbejrs feladata.
Bizonyts: azt lltjuk, hogy kell legalbb |E|/2 input olvass.
Minden lszmra tudunk olyan grfot konstrulni, hogy ennl kevesebb olvasssal
ne legyen eldnthet a grf sszefggsge. Legyen G1 s G2 kt egyforma, tetszleges
sszefgg grf, az inputnak a kt komponense. Ha nem olvassuk vgig legalbb az
egyiknek az sszes lt, akkor G1 s G2 egy-egy nem vgigvizsglt cscsa kz berakhatunk
egy j let (az llistik vgre), ezt az algoritmus nem veszi szre.
12

Az albbiakban megnznk nhny fontos feladatot, amelyeket a szlessgi keress


segtsgvel knnyen megoldhatunk.

2.1. sszefgg-e a grf?


Ha minden 1 i n-re L(i) = 1, akkor a grf sszefgg, klnben nem.

2.2. Grfok komponenseinek meghatrozsa


A grf egy adott komponense egy ekvivalencia osztly, ezt gy troljuk, hogy tetszlegesen elnevezzk a komponenseket, s egy cscsra az t tartalmaz komponens sorszmt
troljuk (kt cscs akkor van ugyanabban a komponensben, ha ez a szm ugyanaz). Nyilvnval megolds: elszr az L tmbben 1-es rtket adunk minden ltott cscsnak, majd
amikor a sor kirl, akkor keresnk egy olyan w cscsot, melyre L(w) = 0, s egy innen
indtott jabb keresssel megkeressk a 2. komponens cscsait, ezekre L rtkt 2-re lltjuk, majd gy tovbb.
Vegyk szre, hogy akr c n2 idt is elhasznlhatunk kizrlag a 0-k keressre:
Pldul, ha a G grf nem tartalmaz leket, akkor az els komponens utn 2 lps az els
0 megtallsa, a msodik utn 3, s gy tovbb, az utols 0 megtallsa n lps.
Hasznos szrevtel: A cscsok ltottsga csak egy irnyba vltozik. Ha az els
bejrsnl az i-edik cscsnl talltunk 0-t, legkzelebb elg az i + 1-edik elemtl kezdeni
a kvetkez nulls keresst.
Az algoritmus:
INIT:
jsor(S, n); jtmb(L, n)
for i = 1 . . . n L(i) := 0
k := 0
for i = 1 . . . n
if L(i) = 0 then k++; L(i) := k; S i
while S 6=
uS
for uv E
if L(v) = 0 then L(v) := k; S v
Lpsszm(llists trolsnl): O(n + m).

2.3. Legrvidebb utak


Feljegyezzk, hogy az egyes cscsokat mely cscsbl lttuk meg (a v cscsot a p(v) nev
szlbl ), s minden cscshoz hozzrendelnk egy SZ(v) szintet.
Az algoritmus:
INIT:
jsor(S, n); jtmb(L, n); jtmb(p, n); jtmb(SZ, n)
for i = 1 . . . n
L(i) := 0; p(i) := i; SZ(i) := 0
13

k := 0
for i = 1 . . . n
if L(i) = 0 then k++; L(i) := k; S i
while S 6=
uS
for uv E
if L(v) = 0 then L(v) := k; S v; p(v) := u
SZ(v) := SZ(u) + 1
1. llts. Szlessgi keress esetn
1. Brmelyik idpontban az S sorban balrl jobbra a szintszm monoton n
2. Ha x, y S, akkor |SZ(x) SZ(y)| 1
Bizonyts: Idre vonatkoz indukcival.

Amikor egy elem van a sorban, trivilisan teljeslnek.


Amikor j elemet rakunk be, elromlanak-e a tulajdonsgok? Tegyk fel, hogy v
beraksakor valamelyik elromlik, legyen v szlje u, teht SZ(u) = SZ(v) 1.
Vegyk szre, hogy a sor minden x elemre, ha SZ(x) 6= SZ(v), akkor x mr a
sorban volt u kivtele eltt is.
1. tulajdonsg:

SZ:

Ekkor x a v bettele eltt is benne volt a sorban, ami ellentmond annak, hogy u
kivtele eltt teljeslt a 2. tulajdonsg.
2. tulajdonsg:

SZ:

Ekkor is x a v bettele eltt is benne volt a sorban, ami ellentmond annak, hogy u
kivtele eltt teljeslt az 1. tulajdonsg.
3. Ttel. Szlessgi keressnl (sszefgg irnytatlan grf esetn)
1. A grf lei nem ugorhatnak t szintet, vagyis, ha uv E, akkor |SZ(u)SZ(v)| 1
2. Minden x cscsra SZ(x) az 1 cscsbl az x-be vezet legrvidebb t hossza.
14

3. Az egyik legrvidebb t: (1, . . . , p(p(x)), p(x), x)


4. Minden cscsot bejrunk az algoritmus sorn, vagyis j az algoritmus.
Bizonyts: (Elz ttel alapjn)
1
u

*
v

1. Nem lehet uv tpus (lsd az brn) l a grfban, mivel amikor u-t kivettk a sorbl,
v mg nem lehetett benne a sorban, gy u tvizsglsa sorn be kellett kerlnie eggyel
nagyobb szintszmmal.
2. s 3. A 3. lltsban felrt (jobbrl balra generlt) cscssorozat valban egy t lesz, s az
1. llts miatt egy legrvidebb t is, mivel a grf lei nem tudnak szintet ugrani.
A hossza nyilvn SZ(x).
4. Jellje d(1, x) egy x cscs tvolsgt az 1-tl. Indirekten tegyk fel, hogy ltezik
olyan cscs, ami 1-bl elrhet, s ahol nem jrtunk. Legyen x az ilyenek kzl
egy olyan, amelyre d(1, x ) minimlis.
1

d(1,x*)

y
x*

Jellje az 1-bl x -ba vezet d(1, x ) hossz t utols eltti cscst y, ekkor y kzelebb van 1-hez, gy x vlasztsa szerint y-ban jrtunk, ezrt valamikor y szerepelt
a sorban. Amikor megvizsgltuk a szomszdait, akkor x -ot is megtalltuk volna.

15

2. llts. {(p(u), u)|p(u) 6= u} E(G) egy fesztfa lesz. Ha a grf irnytott, akkor a
gykrtl elfel irnytott fkat (fenyket) kapunk.
Bizonyts: Ez n 1 darab l, ha nem fesztfa lenne, akkor lenne benne kr, ez azonban
nem lehet, mert a kr cscsai kzl a sorba leghamarabb berakottnak a szlje nem lehet
egy ksbb berakott.

2.4. Ktsznezhetsg
Tudjuk (de most jra be is bizonytjuk), hogy egy grf akkor s csak akkor nem ktsznezhet, ha van benne pratlan kr. Sznezzk a grf cscsait az albbi mdon: Legyen
piros, ha SZ rtke pros s kk, ha SZ pratlan.
Mikor nem j ez a sznezs? Felhasznljuk, hogy a grf lei nem ugorhatnak t szintet.
Problma csak az egy szinten bell men lekkel lehet. Legyen egy ilyen szinten belli l
u s v kztt.

Az algoritmust egsztsk ki az else if SZ(u) = SZ(v) then PTLANKR(u, v)


sorral.
PTLANKR(u, v): megkeressk u s v legkzelebbi kzs st. Az gy meghatrozott kr valban pratlan, gy a grf nem ktsznezhet.
A kr kiratsa: Felvltva a szlre lpkedve keressk meg az x legkzelebbi kzs st,
s kzben rakjuk v, p(v), . . . , p(. . . (p(v)) . . . ), . . . x-et egy verembe,
u, p(u), . . . , p(. . . (p(u)) . . . ), . . . x-et pedig egy sorba. Ha kirtjk a vermet, majd a sort,
akkor az adott kr cscsait soroljuk fel, a sor utols elemt mr nem ratjuk ki.

2.5. Irnytott grfok


Minden cscsot elrnk, amibe van 1-bl irnytott t. Ekkor is a legrvidebb ilyet talljuk
meg. Ebben az esetben a grf lei visszafel mr tugorhatnak szintet, lefel ugyangy
nem.
Irnytott grfok esetn ktfle sszefggsget is definilhatunk:

Gyenge sszefggsg: Ha eltekintnk az irnytstl, akkor sszefgg-e a grf (azaz, ha pldul a grfok lei kzlekedsi utakat jellnek, eljuthatunk-e mindenhonnan
mindenhov egy biciklin)?

Ekkor lnyegben az a krds, hogy G sszefgg-e.

16

Ers sszefggsg: Brmely x, y V esetn ltezik-e x-bl y-ba men irnytott


t?
Trivilis megolds: n darab szlessgi keress (minden cscsbl indtunk egyet).

Jobb megolds: Csinlunk egy szlessgi keresst az eredeti grfban, G -n 1-bl,

majd mg egy szlessgi keresst a fordtott G grfban szintn 1-bl. gy sszessgben 2 szlessgi keress elegend az ers sszefggsg eldntshez, mivel G
ersen sszefgg akkor s csak akkor, ha mindkt keressben minden cscs ltott
vlik.

3. (Binris) Kupac
Egy fa kupacrendezett, ha igazak r a kvetkez tulajdonsgok:

Gykeres fa, melynek cscsaiban rekordok helyezkednek el.


Minden rekordnak van egy kitntetett mezje, a K KULCS.
Brmely v-re, ha ltezik a p(v) szl, akkor K(rek(p(v))) K(rek(v)) (ezt ezentl
K(v)-vel jelljk), azaz v leszrmazottaira igaz, hogy az ott tallhat kulcsok minimuma van v-ben. (Egy cscsot mindig sajt maga leszrmazottjnak tekintnk.)

Kupac: (egyszer kupac, binris kupac)

Kupacrendezett binris fa (egy cscs gyermekeinek szma 0, 1 vagy 2)


A levelek vagy egy, vagy kt szomszdos szinten vannak, ez utbbi esetben igaz,
hogy a fels tele van, az alsn pedig balra vannak rendezve a levelek. (Teht a
binris fban a szinteket mindig balrl jobbra haladva tltjk fel.)

Trols: a kulcsokat egy A tmbben troljuk:

A(1) a gykr kulcsa.


Az i. cscs bal finak kulcsa A(2i)-ben lesz, jobb fi pedig A(2i + 1)-ben.
Az i. cscs szljnek kulcsa A(bi/2c).
Ezenkvl mg trolunk egy VGE pointert (szmot), mely megadja, hogy pillanatnyilag hny elem van a kupacban.

Megjegyzs: Igazbl legtbbszr 3 tmbre van szksgnk. Az A-ban troljuk a cscsok kulcsait,
a B tmbben vagy az i-edik cscsban trolt objektum nevt, vagy a megfelel rekordra mutat
pointert, s C(j) pedig a j nev cscs (ill. rekord) indexe az A-ban s B-ben. ltalban csak az A
tmbbel val opercit adjuk meg, a tbbi kitallhat. De pldaknt a FELBILLEGTET eljrsban
megadjuk ezeket is. Persze ha a nevek nem 1 s n kztti szmok, akkor a C tmb helyett egy
sztrra van szksgnk, ld. ksbb.

17

Plda:
2
5

12

A:

10

15

2 4 5 6 7 8 9 12 10 15

Mveletek :
jkupac(A, n): egy j, res kupacot hoz ltre (n az egy idben a kupacban szerepl
elemek maximlis szma).
Beszr(A, j): egy j elemet szr be a kupacba.
Mintrls(A): a minimlis kulcs elemet kiveszi a kupacbl s visszaadja.
Kulcs-cskk(A, elem, ): a kupacban lv elem kulcst cskkenti -val. (Csak 0
esetn kell mkdnie). Az elem-et gy hatrozzuk meg, hogy rmutatunk egy pointerrel
(nem tudjuk megkeresni, mivel a kupacban nem tudunk hatkonyan keresni), azaz a
C(elem)-edik kupacelem kulcst cskkentjk.

Mveletek megvalstsa:
jkupac(A, n):
jtmb(A, n); VGE:= 0
Beszr(A, j):
tlet: nyilvn az A tmb els res helyre kell beraknunk az j elemet, ez meghatrozza, hogy a fban hov kerl az j levl. A kupactulajdonsg csak egy l mentn
romolhatott el (az j levl s a szlje kzttin). Ezen l mentn javtjuk a kupactulajdonsgot, ekkor felette egy msik l mentn romolhat el, gy ismteljk, amg mindenhol
helyre nem ll (lehet, hogy egszen a gykrig el kell mennnk).
Beszr(A, j):
VGE++
A(VGE) :=K(j)
B(VGE) :=j; C(j) :=VGE
FELBILLEGTET(A,VGE)

18

FELBILLEGTET(A, i):
AA := A(i); BB := B(i)
while i > 1 && A(bi/2c) > AA
A(i) := A(bi/2c)
B(i) := B(bi/2c)
C(B(i)) := i
i := bi/2c
A(i) := AA
B(i) := BB
C(BB) := i
Lpsszm: A fa mlysge blog nc, amibl kvetkezik, hogy a FELBILLEGTET lpsszma O(log n).
3. llts. Beszrs utn a kupactulajdonsg helyrell.
Bizonyts: gy tekintjk, hogy mindig i s szlje tartalmt felcserljk egy-egy lpsben. llts: mindig csak i s a szlje kzti l mentn lehet baj a kupactulajdonsggal.
Ez kezdetben igaz. Ha i gykr, vagy szljnek kulcsa kisebb-egyenl, akkor itt sincs baj,
teht ksz vagyunk. Klnben csere utn ezen l mentn a kupactulajdonsg helyrell,
s mivel a szlben lv kulcs cskken, a msik gyereke fel men l sem romlik el, teht
csak az j i s szlje kztti len lehet baj.
Mintrls(A): Kicserljk a gykeret s az utols elemet, majd trljk az utols
elemet. Itt kt len is elromolhatott a kupactulajdonsg. Ha cserlni kell, akkor a kt
gyerek kzl mindig a kisebb kulcsval cserlnk.
Mintrls(A):
csere(A(1), A(VGE)); VGE
LEBILLEGTET(A, 1)
return(A(VGE+1))
LEBILLEGTET(A, i):
AA := A(i); j := 2i + 1 / j a jobb gyerek
while j VGE
if A(j 1) < A(j) then j / tlltjuk j-t a bal gyerekre
if A(j) < AA then A(i) := A(j); i := j; j := 2i + 1
else j :=VGE+2 / kilpnk, kszen vagyunk
j / mg kezelnnk kell azt az esetet, ha i-nek csak bal gyereke van
if j VGE && A(j) < AA then A(i) := A(j); i := j
A(i) := AA
4. llts. Mintrls utn a kupactulajdonsg helyrell.
Bizonyts: gy tekintjk, hogy mindig i s kisebbik kulcs gyereke tartalmt felcserljk egy-egy lpsben. llts: mindig csak az aktulis i s a gyerekei kzti lek mentn
19

lehet baj a kupactulajdonsggal. Ez kezdetben igaz. Ha i-nek nincs gyereke, vagy mindkt gyereknek kulcsa nagyobb-egyenl, akkor itt sincs baj, teht ksz vagyunk. Klnben
csere utn ezen lek mentn a kupactulajdonsg helyrell, s csak az j i s gyerekei kztt
romolhat el.
Lpsszm: O(log n)
Kulcs-cskk(A, elem, ):
i := C(elem)
A(i) := A(i)
FELBILLEGTET(A, i)
Lpsszm: O(log n)
Alkalmazsok:
Rendezs: res kupacba sorban Beszrjuk az elemeket, majd sorban Mintrlnk, ez
O(n log n) lps. Az albbi, lineris idej Kupacpts segtsgvel kicsit jobb lesz. Ezt
fleg olyan esetekben rdemes hasznlni, amikor a feladat pldul az els k legkisebb elem
kiratsa (nagysg szerinti sorrendben), ekkor a futsi id O(n + k log n) lesz.
KUPACPTS (nem alapmvelet): n darab elem kupacba szervezse.
Tetszlegesen feltltjk a tmbt, majd alulrl felfel rakjuk rendbe a kupacot. A levelek j egyelem kupacok. Az egy magassg rszfk egy lebillentssel kupac-rendezett
alakthatak. ltalban, ha v gyerekeinek rszfi mr kupacrendezettek, akkor v LEBILLEGTETsvel v rszfja is azz vlik.

20

Az algoritmus:
az adatok betltse tetszlegesen az A tmbbe.
for i = dn/2e . . . 1 (1)
LEBILLEGTET(A, i)
Lpsszm: (sszes lebillentsek szma)=
3
n
0 + n4 1 + n8 2 + + 1 dlog ne n ( 14 + 28 + 16
+ ...)
2
1
2
3
a := ( + + + . . . ), knnyen lthatan ez a sor abszolt konvergens (majorlja a
P 3 i 4 8 16
3
2
mrtani sor), ezrt az a szm ltezik. Ekkor a a2 = ( 14 + 28 + 16
+ . . . ) ( 18 + 16
+
4
3
1
1
1
1
+
.
.
.
)
=
(
+
+
+
.
.
.
)
=
=
a
=
1.
32
4
8
16
2
Azaz legfeljebb n darab lebillents kell, gy O(n) elemi lps lesz a lpsszm.
Kvetkezmny: Ha n elembl a k darab legkisebbet keressk rendezve, akkor ennek a
lpsszma O(n + k log n) lesz.
Tovbbi alkalmazsok tallhatk a kvetkez fejezetekben.

4. Minimlis kltsg fesztfa, legrvidebb t keresse


Adott: G = (V, E) sszefgg, irnytatlan grf c : P
E R lkltsgekkel.
Feladat: Olyan fesztft keresnk, melyre c(T ) = eT c(e) minimlis.

4.1. Kruskal algoritmusa


I. FZIS: rendezzk az leket kltsg szerint: c(e1 ) c(e2 ) c(e3 ) c(em ). Ez
O(m log n2 ) = O(m log n) idben megy, ahol m = |E| s n = |V |.
II. FZIS: nyilvntartjuk a komponenseket: K = {{v1 }, {v2 }, . . . , {vn }}
T :=
for i = 1 . . . m
if not ei kt vge egy komponensben
then T := T + ei ; kt komponens unija.
Megjegyzs: persze ha azt is figyeljk, hogy T -ben mikor lesz n 1 l, akkor mr meg is llhatunk.

Naiv megolds a komponensek nyilvntartsra: minden l megptsekor (T -be val


bevtelekor) lefuttatunk egy szlessgi keresst (komponensekre bontst) a T grfon. Ez
sszesen O(n2 ) lps. Ezen majd javtani szeretnnk.
4. Ttel. Ez az algoritmus valban minimlis kltsg fesztft ad.
Bizonyts:

T:

e1

e2

e3

21

+/- jeleket tesznk aszerint, hogy az adott l benne van-e T -ben (T az algoritmus ltal
adott fa).
Legyen T olyan optimlis fa, melyre a +/ sorozat a lehet leghosszabban megegyezik
T -vel. Legyen az els klnbsg az i. oszlopban.
1. eset (/+):
ei
T:

T*:

Ez nem lehetsges, mivel ha a T -be az algoritmus sorn nem vettk be az ei let, akkor
ei kt vgpontja ssze van ktve kisebb sorszm lekkel, azonban: j < i-re ej T , teht
ej T . Ekkor ei mr a T eddigi leivel is krt alkot, ez pedig ellentmonds.
2. eset (+/):
ei
T:

T*:

Mi lesz T + ei ? Mivel T fesztfa, ebben lesz pontosan egy C kr. Legyen ej a maximlis
index le a C-nek.
5. llts. j > i.
Bizonyts: klnben T -ben is ott lenne a C kr, hiszen T az i-nl kisebb index leken
megegyezik T -gal.
Kvetkezmny: c(ej ) c(ei )
T +ei ej fesztfa lesz (hiszen az egyetlen krbl hagyunk el egy lt). c(T +ei ej )
c(T ) = OPTIMUM. Teht T + ei ej is optimlis megolds, de ez ellentmonds, mert
ez mr az i. oszlopban is megegyezik T -vel.

Kvetkezmnyek :
1. Ha G-ben brmely kt l kltsge klnbzik, akkor egyrtelm az optimlis fesztfa.
2. Ha az sszes lehetsges j (kltsg szerint monoton nv) l-rendezst vesszk, majd
ezekre lefuttatjuk az algoritmust, akkor megkapjuk az sszes optimlis (minimlis
kltsg) fesztft.
22

Bizonyts: T -hoz a sorrend megvlasztsa:


Az azonos kltsgeket gy rakjuk sorba, hogy a T -ban szerepl lek legyenek ell.
Az elz bizonytst vgiggondolva knny ltni, hogy ekkor az algoritmus ppen T -ot
adja.
A II. FZIS megvalstsa: DISZJUNKT-UNI s HOLVAN mveletekkel.
HOLVAN(x):= az x-et tartalmaz halmaz neve (ez egyrtelm, mivel a halmazok
diszjunktak).
D-UNI (H1 , H2 ): H := H1 H2 , azaz lecserljk H1 -et s H2 -t egy j, H nev
halmazra.
A II. FZIS sorn legfeljebb 2m darab HOLVAN s pontosan n 1 darab D-UNI
mveletet hajtunk vgre (mivel egy ft ptnk).

4.2. DISZJUNKT-UNIHOLVAN adatstruktrk


3 megvalstst fogunk vizsglni:
A) megolds: A tmbbel. A(i) tartalmazza az i. cscsot tartalmaz halmaz nevt.
1

n
H2

H2

H2

H2

INIT: for i := 1 . . . n
A(i) := i
Lpsszm: O(n).
HOLVAN(i): return(A(i))
Lpsszm: O(1).
D-UNI(H1 , H2 ):
for i := 1 . . . n
if A(i) = H2 then A(i) := H1
Lpsszm: O(n)
A II. FZIS sszlpsszma: O(m + n2 ) = O(n2 ).
Megjegyzs: Sr grfokra ez a j megolds.

Kitr: Amikor algoritmusok lpsszmt akarjuk megbecslni, a konstans szorzt


nem tekintjk lnyegesnek. 1 Lps-nek (ejtsd nagy lps) konstans sok elemi lpst
fogunk nevezni a tovbbiakban. St, ha szksg lesz r, ezt a konstanst nvelni is fogjuk
az elemzs sorn (ez nem fog gondot okozni, mert a nagyobb konstansba belefrnek a
nvels eltti kisebb konstansok is).
B) megolds: tmbkkel s lncolssal okosabban:
4 tmbt hasznlunk:
A(i) az i cscsot/elemet tartalmaz halmaz neve
L : a halmaz kvetkez elemre mutat pointereket troljuk
K(j) a j. halmaz els eleme
M (j) a j. halmaz mrete
23

Ha H2 a kisebbik halmaz, akkor a H2 elemeinl rjuk t az A tmb megfelel rtkt,


s a H2 vgre fzzk a H1 -et, hogy annak elemein ne kelljen vgigmenni.

3
1

6
1

8
1

20
1

20

nincs tbb elem a halmazban

kvetkez elem a halmazban

INIT:
for i := 1 . . . n
A(i) := i; L(i) := 0; K(i) := i; M (i) := 1
HOLVAN(i): return(A(i))
D-UNI(H1 , H2 ):
if M (H1 ) < M (H2 ) then csere(H1 , H2 )
/ felcserljk a halmazok neveit = H1 lesz a nagyobb mret
M(H1 ):= M(H1 )+M(H2 )
i := K(H2 )
while L(i) 6= 0
A(i) := H1 ; i := L(i)
A(i) := H1
L(i) := K(H1 )
K(H1 ) := K(H2 )
Elemzs: most nem 1 darab D-UNI mvelet lpsszmt vizsgljuk, hanem azt, hogy
az algoritmus az n 1 darab D-UNI mvelet sorn sszesen hny lpst tesz.
Az elemzs mdszere a strigulzs lesz: egy tblzatot ksztnk elre, s az algoritmus minden egyes Lpsnl hzunk egy strigult a tblzat megfelel helyre. A vgn
sszeszmoljuk, hogy sszesen hny strigult hztunk s ez lesz az algoritmus Lpsszma.
A Lps konstanst gy lltjuk be, hogy egy D-UNI annyi Lps legyen, mint a
kisebbik halmaz mrete. gy egy mvelet min(|H1 |, |H2 |) Lps lesz. (Egy konkrt DUNI mvelet esetn ennek a lpsszma picit rosszabb a konstans nagyobb is lehet,
mint az elz megvalstsban.)
Strigulzs:
1

1. D-UNI
2. D-UNI
3. D-UNI

A j. D-UNI mveletnl a j. sorban i al hzunk egy strigult, ha A(i) tartalma megvltozott. gy pont min(|H1 |, |H2 |) strigult hzunk be ennl a mveletnl.
24

6. llts. Minden i-re i al legfeljebb log n strigult hzunk.


Bizonyts: Minden cscs elszr egy egy elem halmazban volt, ezutn minden strigula behzsakor egy legalbb ktszer akkora mretbe kerl (hiszen a kisebbik halmaz
elemeinl hzunk strigult). gy log n strigula utn egy n elembe kerl, teht kszen
vagyunk.
gy n 1 darab D-UNI lpsszma O(n log n) lesz.
Ezrt a II. FZIS lpsszma O(m + n log n), ez mr egyrtelm javts, s m >
n log n esetn optimlis is.
Okok, amirt a II. FZIS gyorstsn rdemes dolgozni (annak ellenre, hogy az I.
FZIS teljes ltalnossgban nem gyorsthat):

Elfordul, hogy eleve rendezve kapjuk az leket, gy nincs is szksg az I. FZIS-ra.


ltalban az lek kltsgei kis egsz szmok, gy O(m) idben rendezhetek (leszmll rendezssel).
Sok ms alkalmazsban is hasznljk a HOLVAN s D-UNI mveleteket.
Nem biztos, hogy a II. fzisban vgig kell menni az sszes elemen, ha szerencsnk
van, a legkisebb n 1 let elg ismerni, teht rendezs helyett a kupac (a lineris
idej kupacptssel) segthet.
A rendezsi algoritmus minden knyvtrban jl meg van rva, gyakorlatban gyorsan
fut.

C) megolds: a D-UNI mveletet akarjuk 1 Lpsben megvalstani, a HOLVAN


mvelet lesz lassabb. ltalban ennek az ellenkezjt fogjuk csinlni, a gyakoribb mveletet gyorstjuk, a ritkbbat lasstjuk. Itt kivtelesen azrt rdemes fordtva, mert a
gyakori HOLVAN mveleten csak picit lasstunk, viszont a D-UNI sokat gyorsul.
Az tlet: A halmazokat gykeres fkknt (mindenkinek csak szlpointere lesz) fogjuk
brzolni, a gykrben a halmaz neve lesz.
H1

HOLVAN(x) : x-bl indulva mindig a szlre lpnk, mg a gykrbe nem rnk, ott
kiolvassuk a halmaz nevt. Az eddigi lustasgunk (unik egy lpsben) miatt ez nagyon
sok lps is lehet. Ilyenkor viszont inkbb mg egyszer annyit dolgozva kicsit javtunk a
fa alakjn, hogy a jvbeni HOLVAN krdseknl mr jobb legyen a helyzet.
D-UNI: r rang segtsgvel. A rang lnyegben a fa magassga lesz, pontosabban egy
fels becsls lesz a fa magassgra. Igazbl a rangokat nem csak a fkhoz (gykerekhez),
25

hanem minden egyes cscshoz hozzrendeljk, egy v cscsnl a v magassgra lesz fels
becsls. Nem gykr cscsok esetn az algoritmushoz nem, csak az elemzshez hasznljuk, teht ilyeneknl trolni sem kell. A rangokat kezdetben csupa nullra inicializljuk.
Mindig a kisebb rang halmazt ktjk t a nagyobba:
H1
H2

Ha r(H1 ) < r(H2 )


H2
H1

Ha r(H1 ) > r(H2 )


H1

H2

Ebben a kt esetben nem n a rang.


Ha r(H1 ) = r(H2 )
H2

H1

r(H1 )++

(A H1 rangjt megnveljk.)

Kitr: Egy cscs (v) mlysge: a gykrbl a v-be vezet t hossza. Egy cscs (v)
magassga: ha l a v alatt a legtvolabbi levl, akkor a v-bl l-be vezet t hossza. A fa
magassga:=gykr magassga= maxv v mlysge=:a fa mlysge.
HOLVAN javtsa: tlet: ha mr sokat kell dolgoznunk, akkor dolgozhatunk egy
kicsivel tbbet, ha ezzel a tovbbiakban idt sprolunk. (A tbbletmunka sorn kicsit
helyrepofozzuk az adatstruktrt.) Ez a mdszer a lustasg kompenzlsra szmtalan
adatstruktrnl be fog mg vlni!
26

trvidts:

Mg egyszer vgigmegynk a fban az x-tl a gykrig vezet ton, s minden szl


pointert a gykrre lltunk (kivve a gykrt).
tfelezs:

Az x-tl a gykrig vezet ton minden cscs szl pointert tlltjuk a nagyszljre (kivve a gykrt s a kzvetlenl alatta lvt). Ehhez nem kell mg egyszer
vgigmenni az ton, egyszeren egy lpssel tovbb megjegyezzk a szl pointereket. Ez
a mdszer akr jobb is lehet, mint az trvidts, mivel itt elg egyszer vgigmenni a fban
a kereston. trvidts esetn pedig jabb ciklust kell kezdennk, amely megkezdse
(elksztse) idt ignyel.
Termszetesen az trvidts s az tfelezs sorn semelyik cscs rangja nem vltozik.
Az trvidts s az tfelezs elemzse
A Kruskal algoritmus n 1 darab D-UNI s m0 = 2m darab HOLVAN mveletet
vgez. Azt fogjuk elemezni, hogy sszesen hny lpsben valsthatjuk ezt meg. Most a
D-UNI O(1) lps, gy a HOLVAN mveletek idejt kell elemeznnk.
7. llts. Adott v-re r(v) az elejn 0 s monoton n. Ha v nem gykr egy adott pillanatban, akkor sose lesz az, s az r(v) mr soha tbb nem vltozik.
8. llts. r(v) < r(p(v)) (ha v nem gykr).
27

Bizonyts: D-UNI mvelet: Ha a kisebb rangt ktttk be a nagyobb al, akkor


teljesl az llts. Egyenl rangaknl szintn teljesl az llts, mivel ekkor az j gykr
rangjt nveljk.
HOLVAN: Ha tktjk, akkor nagyobb rangba ktjk, s mivel tkts eltt teljeslt
ez a tulajdonsg, ezrt nem romolhat el.
9. llts. x gyker fban van legalbb 2r(x) darab elem, ezrt v : r(v) blog nc.
Bizonyts: 1 pont fra teljesl az llts.
D-UNI mveletnl: klnbz rangak esetn nyilvn teljesl. Egyenl rangnl: mindkt fban legalbb 2r(x)1 darab elem van, ahol r(x) az Uni utni rang, a bekts utn
legalbb 2 2r(x)1 = 2r(x) elem lesz a fban. A HOLVAN mvelet nem vltoztatja meg
ezt a tulajdonsgot.
10. llts.



{v | r(v) = k} n .
2k

Bizonyts: Av := {w | w a v leszrmazottja volt, amikor r(v) = k lett}.


Beltjuk, hogy ha r(x) = k s r(y) = k s x 6= y, akkor Ax Ay = . (Az elz llts
miatt |Ax | 2k , teht ebbl tnyleg kvetkezik az egyenltlensg.)
Tegyk fel, hogy y ksbb lett k rang, mint x. Ekkor x nem volt benne az y gyker
fban a 8. llts miatt. Ugyanakkor Ax minden eleme x-szel azonos fban volt, teht a
kt halmaz valban diszjunkt. (Az llts k = 0 esetn trivilisan igaz.)
Definci: Torony fggvny: T (0) = 1 s T (n + 1) = 2T (n) .
Az inverze: log (n) = min{k | T (k) n}
Megjegyzs: Ha n 265536 log (n) 5. (Az univerzumban a tudomny jelenlegi llsa
szerint kb. 2270 , teht sokkal kevesebb, mint 265536 rszecske van.)

Rangcsoportok:
0

R0

R1

R2

16

R3

17

65536

R4

Ri := [T (i 1) + 1, . . . , T (i)], s R0 = [0, 1]. A v cscs az Ri rangcsoportban van, ha


r(v) Ri .
Elemzs: A Lps konstanst gy lltjuk be, hogy egy D-UNI 1 Lps legyen, egy
HOLVAN pedig annyi Lps, ahny cscsot rintnk a keress (felfel lpkeds) sorn.
A HOLVAN mveleteket gyesen fogjuk elemezni, minden egyes mvelet sorn annyi
strigult fogunk behzni, ahny cscsot rintettnk. Azonban a strigulkat klnbz
helyekre fogjuk behzni. A vgn sszeszmoljuk (fellrl becsljk) majd az sszes
helyen lv strigulkat.
2 fle helyre fogunk strigult hzni: vagy az adott mvelethez (i. HOLVAN), vagy a
cscsokhoz (az alaphalmaz elemeihez).
28

Az i. HOLVAN mveletnl a strigulzsi szably a kvetkez. A mvelet sorn bejrt


t brmely v cscsra:
Behzunk egy strigult az i. HOLVAN mvelethez, ha:

v vagy p(v) gykr, vagy


ha v szlje nem ugyanabban a rangcsoportban (teht nagyobban) van, mint v.

Minden ms esetben a v cscshoz hzunk egy strigult.


Az sszes (m0 darab) HOLVAN mvelet utn megszmoljuk, hogy hny strigula van
a mveleteknl s mennyi a cscsoknl.
Maximlis rang log n a legnagyobb rangcsoport R , ahol log (log n) =
log (n)1. Teht legfeljebb log (n) darab rangcsoportunk van. (A 0-s csoporttal egytt.)
Az i. HOLVAN sorban a strigulk szma legfeljebb 2 + (log (n) 1) = log (n) + 1,
mert az t mentn a rangcsoport legfeljebb (log (n) 1)-szer nhet.
Hny strigult hzhattunk sszesen egy cscs mell? Mikor hzunk strigult egy v
cscs mell?

Csak akkor kezdnk el strigulkat hzni egy v cscs mell, ha mr nem gykr, s
a szlje sem az. Ezutn mr v rangja nem vltozik.
tfelezs/trvidts esetn, ha sem v sem p(v) nem gykr, akkor a v cscs szl
pointere egy szigoran rgebbi sre fog mutatni. gy a rang szigor monotonitsa
miatt r(p0 (v)) > r(p(v)), azaz v j p0 (v)-vel jellt szljnek rangja szigoran
nagyobb, mint az tkts eltti szlj.
Ha r(v) = r, akkor v a g := log (r)-edik rangcsoportban van.

11. llts. Ilyen strigulzsi szablyok mellett egy tetszleges g-edik rangcsoportbeli v
cscs mell legfeljebb T (g)T (g 1) strigula kerlhet g 1 esetn, g = 0 esetn pedig
maximum 1.
Bizonyts: g 1 esetn T (g) T (g 1) szm van a g. rangcsoportban. Ha mr
kerlt strigula v mell, akkor r(v) nem vltozik, mg r(p(v)) idben n. Azonban ha
a g. rangcsoporton tlntt, akkor az adott v cscs mell mr soha tbb nem hzunk
tbb strigult. Teht egy g rangcsoportbeli v cscshoz maximum T (g)T (g 1) strigula
kerlhet.
Strigulk sszeszmolsa:
N (g) jellje azt, hogy maximlisan hny cscs lehet a g-edik rangcsoportban. A 10. llts
miatt:
T (g)
X
n
1 1
n
n
n
T (g1)+1 (1 + + + . . . ) = T (g1) =
.
N (g)
r
2
2
2 4
2
T (g)
r=T (g1)+1

sszefoglalva: g rangcsoportbeli cscsok mell sszesen legfeljebb T n(g) (T (g)T (g 1))


n strigula kerlhet.
Ez igaz g = 0-ra is, mivel legfeljebb n darab cscs lehet a 0. rangcsoportban s a 0-s
rangcsoport cscsok mell csak 1 strigula kerlhet.
29

gy sszesen a cscsok mell legfeljebb log (n)n strigula kerlt, mivel log (n) rangcsoport
van.
Lpsszm: O(n 1 + m0 (log (n) + 1) + n log (n)) = O((n + m0 ) log (n)), ahol m0
a HOLVAN mveletek szma.
Ha a Kruskal algoritmus II. FZIST gy valstjuk meg sszefgg grfra (ekkor:
0
m = 2m > n), akkor a lpsszm O(m log (n)) lesz, ami gyakorlati szempontbl lnyegben linerisnak tekinthet. Valjban a legrosszabb esetben tnyleg nem lineris, nem
csak mi voltunk nagyvonalak az elemzsnl.

4.3. Prim algoritmusa


Az algoritmus tlete: Kezdetben induljunk ki az 1-es szm cscsbl, majd minden egyes
lpsben bvtsk ezt a ft (s az S cscshalmazt), gy, hogy a belle kiindul (S s
V S kztti) legkisebb kltsg let vesszk hozz.

min

T : aktulis fa
S: T-nek a cscshalmaza
P := {v V S | uv E, u S}
M := V S P
A P -beli cscsokra kt dolgot tartunk nyilvn:

K(v) := min{c(uv) | u S} - ha a v cscsot ktjk be kvetkeznek, akkor ez


milyen kltsggel fog jrni.
p(v) := argmin{c(uv) | u S} - ha t ktjk be, melyik cscshoz kell ktni (ha
tbb ilyen cscs is van, akkor kzlk az egyik).

Az algoritmus:
INIT: P := {1}; S := ; M := V {1}; T :=
K(1) := 0; p(1) := 1
while P 6=
v legyen a P -ben minimlis K(.) rtk cscs
S v P / v-t trakjuk S -be
if p(v) 6= v then T := T + {p(v), v} / A fa megfelel lt megptjk
for vu E
30

if u P && c(vu) < K(u) then K(u) := c(vu); p(u) := v


if u M then K(u) := c(vu); p(u) := v; P u M
Lpsszm:
Szomszdsgi mtrix esetn: O(n2 ) (lttuk a szlessgi keressnl, hogy ennl gyorsabban nem is lehet).
llistval, kupacokkal :
Mvelet
Mintrls
Kulcs-cskk
Beszrs

Vgrehajtsok szma
n
m
n

Mindegyik mvelet O(log n) idej, ha binris kupaccal csinljuk. gy az algoritmus


O(m log n) idej lesz.
Megjegyzs: ritka grfok esetn ez sokkal jobb, mint az O(n2 ), de mg javtani fogunk rajta. Az algoritmus jsgt nem bizonytjuk, a Kruskal algoritmusnl tanult mdszerrel knny (e1 , e2 , . . . , en1
legyenek az algoritmus ltal megptett lek az ptsek sorrendjben, utna a tbbi l sorrendje
tetszleges).

4.4. Dijkstra algoritmusa


Adott: G = (V, E); s c : E R+
0 (hosszsg fggvny, nha kltsgnek hvjuk).
Feladat: keressk meg az s-bl t-be vezet legrvidebb utat.
Az algoritmus tlete: Irnytatlan grfokra jl szemlltethet, ha elksztjk a grfot gy, hogy a cscsok gyngyk, az lek megfelel hosszsg crnk. Lefektetjk az
asztalra, s s-nl fogva lassan felemeljk. Amikor egy cscs felemelkedett, vonalzval lemrhetjk az s gyngytl val tvolsgt, s nyilvn ez lesz a legrvidebb t hossza abba
a cscsba. Ezt szmtgpen gy fogjuk szimullni, hogy minden egyes olyan gyngyhz,
ami az asztalon fekszik, de megy belle crna a levegbe, kiszmtjuk, hogy ha legkzelebb
emelkedne fel, akkor milyen messze lenne s-tl. Knny meggondolni, hogy legkzelebb
az a gyngy fog felemelkedni, amelyre a legkisebb szmot rtuk.
A megvalsts nagyon hasonlt a Prim algoritmushoz, holott az alapelv elgg klnbz, ez egyltaln nem egy moh algoritmus, inkbb dinamikus programozsi. Minden
egyes lpsben azt fogjuk trolni az egyes cscsokra, hogy hol vannak, s hogy mi az eddig
ide tallt legrvidebb t K(v) hossza (azaz ha v emelkedne fel legkzelebb, akkor milyen
messze lenne s-tl). Minden egyes lpsben a P -beli legkisebb kulcs cscsot emeljk
fel, majd szomszdain mdostjuk a kulcsot.
S: a levegben lv gyngyszemek.
P : olyan gyngyszemek, amelyek az asztalon vannak, de van olyan szomszdjuk, ami
a levegben van.
M : a tbbi cscs.
Megjegyzs: Negatv lhosszakkal nem fog mkdni az algoritmus. Viszont irnytott grfokra
formlisan ugyanez az algoritmus j lesz.

31

Az algoritmus:
INIT: P := {s}; S := ; M := V {s}
K(s) := 0; p(s) := s
while P 6=
v legyen a P -ben minimlis K(.) rtk.
SvP
for vu E
if u P && K(v) + c(vu) < K(u) then
K(u) := K(v) + c(vu); p(u) := v
if u M then K(u) := K(v) + c(vu); p(u) := v; P u M
1. Definci. Egy s

x t S-t, ha minden cscsa S-ben van, kivve esetleg x-et.

5. Ttel. Az algoritmus sorn minden while ciklus vgn:


(a) Brmely x S-re K(x) a legrvidebb s
x t hossza, s az ilyen hosszsg utak
kztt van S-t is.
(b) Minden x P -re K(x) a legrvidebb S-t hossza.
Bizonyts (vzlatosan): (a) Elg az ppen S-be trakott cscsra beltni, legyen ez r.
Az r-be nem ltezik K(r)-nl rvidebb t:

S
r
h

>=0

Indirekt tegyk fel, hogy ltezik ennl rvidebb Q t, ekkor az indukcis feltevs szerint
ez nem S-t, legyen az els P -beli cscsa w 6= r. Ekkor r defincija miatt K(r) K(w),
s gy az indukcis feltevs miatt a Q t s-tl w-ig terjed rsze nem rvidebb, mint az
r-be vezet legrvidebb S-t K(r) hossza. Mivel az lhosszak nemnegatvak, a Q t w-tl
r-ig terjed rsze is nemnegatv, teht sszesen Q hossza legalbb K(r), ami ellentmond
Q vlasztsnak.
Az lltsok tbbi rsze hasonlan bizonythat.
6. Ttel. (a) Ha az S-be kerls sorrendjben veszem a cscsokat
(vi : i.-nek kerlt S-be), akkor K(v1 ) K(v2 ) K(vn ).
(b) Ha utoljra v kerlt S-be, akkor minden u P -re K(v) K(u) K(v) +
maxxyE c(xy).
32

Bizonyts: szintn indukcival, elszr (b)-t rdemes. Ha utoljra v kerlt S-be, akkor
minden u P -re K(v) K(u), mert a v-t gy vlasztottuk. A kulcsmdostsok eltt az
indukcis feltevs miatt (mind a kt rszt hasznlva) a msodik egyenltlensg is fennllt,
s kulcsmdosts kzben nyilvn nem romolhat el egyik egyenltlensg sem. Ebbl az
(a) rsz rgtn kvetkezik.
12. llts. Az x cscsba vezet egyik legrvidebb t (htulrl elre lltjuk el):
s, . . . , p(p(x)), p(x), x.

Megjegyzsek.
Figyeljk meg, hogy itt implicit outputot ad meg az algoritmus. Ha fel akarnnk rni az
sszes cscsba vezet legrvidebb utat, az akr c n2 hossz is lehetne. Ehelyett a p tmbt
adjuk ki outputknt (ami a legrvidebb utak fjnak egy lersa), melybl brmely legrvidebb
t annyi idben krdezhet le, mint az leinek a szma.
Az algoritmus mdosthat gy, hogy pld. legszlesebb, ill. legbiztonsgosabb utat keressen.
Ha a fordtott grfon futtatjuk, minden cscsbl egy adott t cscsba vezet legrvidebb utakat
keressk meg.
Ha kt klnbz slyfggvny (c1 s c2 ) adott az leken, akkor meg tudjuk keresni a c1 szerinti
legrvidebb s
t utak kzl azt, amelyik a c2 szerint a legrvidebb. Elszr futtassunk c1
szerinti Dijkstrt a grfon s-bl, s a fordtottjn t-bl. Ezutn minden v cscsra tudjuk a
d(s, v) s d(v, t) tvolsgokat. A c2 szerinti Dijkstra futtatsnl az olyan leket hagyjuk
figyelmen kvl, amelyekre c1 (uv) > d(s, t) d(s, u) d(v, t).
Ha megengedjk a negatv lhosszakat, akkor a feladat N P -nehz lesz (pld. csupa 1 lhossz
esetn Hamilton-t ltezst is el kellene dnteni).
Irnytott grfok esetn, ha brmely irnytott kr nemnegatv, akkor van msik algoritmus
(Bellman-Ford), amely helyes s polinomilis, de lassabb: O(m n).
Viszont aciklikus irnytott grfok esetn negatv lslyra is van kicsit egyszerbb, O(m) idej
algoritmus, ezt hasznljk pld. a PERT mdszerben.
Irnytatlan esetben, ha nincs negatv kr, akkor szintn ltezik polinomilis algoritmus, de az
bonyolultabb.

Elemzs
Ugyangy, mint a Prim algoritmusnl, teht szomszdsgi mtrix esetn O(n2 ) a lpsszm, llista esetn, ha valamilyen kupacot hasznlunk, akkor pedig legfeljebb n darab
Beszrs, n darab Mintrls, s m darab Kulcs-cskk kell.

4.5. d-edfok kupacok


2. Definci. Egy fa d-edfok kupac, ha
minden cscsnak legfeljebb d gyereke van,
kupacrendezett,
kiegyenslyozott.

33

Tmbs megvalsts esetn 0 az els index, s az i index cscs gyerekeinek indexei


c. A kiegyenslyozs itt (is) azt jelenti,
d i + 1, d i + 2, . . . , d i + d. Teht a j szlje b j1
d
hogy a tmbben nincs lyuk.
A mveleti idk vltozsa:
Beszrs, Kulcs-cskk (felbillegtets): O(logd n)
Mintrls (lebillegtets): d gyerekbl minimum kivlasztsa: d 1 sszehasonlts, meg
az aktulis kulccsal val hasonlts = d db. sszehasonlts lebillentsenknt. Mivel a fa
mlysge logd n, gy O(d logd n) addik.
rdekes eset: d = 4. Itt:
Felbillegtets: log n helyett log4 n = log2 n .
Lebillegtets: 2 log n helyett 4 log4 n = 2 log n, azaz ugyanannyi.
Teht sszessgben egyrtelmen jobb, mint a binris kupac.
4.5.1. A Dijkstra s Prim algoritmus lpsszma d-edfok kupaccal
Mi vajon a legjobb d? Erre ltalban nincs egyrtelm vlasz, az egyes mveletek gyakorisgtl fgg.
Tekintsk a Dijkstra (vagy a Prim) algoritmust. Itt az egyes mveletek szma:
n db Beszrs, Mintrls
m db Kulcs-cskk
Az elv: gyorstsuk amibl sok van. A teljes lpsszm: O(n d logd n + m logd n) =
O(max(n d logd n, m logd n)). Az els tag d 3-ra szigoran nv, a msodik szigoran
cskken, teht a maximum a lehet legkisebb rtket ott veszi fel, ahol a kett egyenl.

n d logd n = m logd n
m
d =
n  l m
m

d := max 2,
n
rtket rdemes hasznlni, mert d-nek egsznek kell lennie s nem akarunk 1-et.
gy a lpsszm O(m logd n). Ez ritka grf esetn (ha m c n) nem nagyon segt,
de srnl igen:

Ha m n1+ d n logd n 1/ a lpsszm: O 1 m = O(m), ha
konstans.
34

5. Amortizcis elemzs
Bemelegts: A Szmll egy egyszer adatstruktra, kt mvelettel:
INIT(n): jtmb(A, n); for i = 1..n A(i) := 0
NV(A): Az A bit-tmb tartalmt azonostjuk a bitek sszeolvassval kapott kettes
szmrendszerbeli a szmmal. Ezt kell eggyel megnvelni. Feltesszk, hogy ez a mvelet
maximum 2n 1 alkalommal lesz meghvva. A NV mveletet is knny megvalstani:
NV(A):
for i = n..1 (1)
if A(i) = 1 then A(i) := 0
else A(i) := 1; i := 0
Mennyi egy NV mvelet lpsszma? Nyilvn a legrosszabb esetben n. De mennyi
lesz tlagosan, azaz m darab NV mvelet sszlpsszma m-mel osztva?
13. llts. Egy NV mvelet tlagosan kt lpsben vgrajthat.
Kpzeljk el a kvetkezt. Minden NV hvskor kapunk kt dollrt. Ki kell fizetnnk
annyi dollrt, amennyit lpnk, teht ahny elemet trunk. Azonban ha marad pnznk,
azt betehetjk a bankba, s ksbb, ha szksges, a bankbl kivett pnznkkel is fizethetnk a lpseinkrt. Ha sose mehet le negatvba a bankszmlnk, akkor ez bizonytja,
hogy m darab NV mvelet sszlpsszma maximum 2m.
Ezt egy kicsit finomabban is csinlhatjuk: nem egy bankot hasznlunk, hanem az
A(i) cellkra rakunk dollrokat. Az a clunk, hogy minden olyan i-re legyen A(i)-n egy
dollr, amelyre A(i) = 1. Az elejn nincs ilyen cella, gy ez teljesl. Ha egy NV
mveletet vgznk, akkor az 1 tartalm rintett cellkbl felvesszk az egy dollrt s
rgtn ki is fizetjk a lpsrt. Amikor elszr rnk 0 tartalm cellhoz, akkor a kapott
kt dollrunkbl az egyiket rrakjuk a most 1 tartalmv trt cellra, a msikkal fizetnk
ezrt az utols lpsrt.

5.1. Potencil s amortizcis id


Bevezetjk az albbi jellseket s fogalmakat:
T Ii : az i. mvelet tnyleges ideje (a Lpsek szma).
Potencil: egy fggvny, amely az adatstruktra tetszleges llapothoz hozzrendel
egy nemnegatv vals szmot. Egy mvelet-sorozat esetn Pi jelli az i. mvelet sorn
ltrejtt struktra potenciljt. P0 = 0 (a kezdeti, res struktra potencilja nulla), s
minden i-re Pi 0.
Az i. mvelet amortizcis ideje, melyet AIi -vel jellnk, a kvetkez:
AIi := T IiP
+ P = T
PIi + (Pi Pi1 ). P
Ekkor i AIi = i T Ii + PT P0 i T Ii .
Teht az amortizcis id egy fels becslst fog adni a mveletek sszidejre.
Megjegyzs: Aki tanulta pl. Johnson algoritmust, vagy a minimlis kltsg folyam/ram feladat dulist,
az mr tallkozott a potencil fogalmval. Egy grf cscsaihoz rendelnk (v) potencilokat, s az eredetileg
c(uv) kltsg uv l reduklt kltsgnek nevezzk a c0 (uv) := c(uv) + (u) (v) mennyisget. Egy s
cscsbl egy t cscsba vezet P t c0 szerinti hossza megkaphat a c szerinti hosszbl, ha hozzadunk (t)-t
s kivonunk (s)-et.

35

Ha most egy adatstruktrhoz ksztnk egy grfot, melynek cscsai a lehetsges llapotok, az lei pedig
a mveletek T I kltsggel, akkor a reduklt kltsgek pont az AI mennyisgek lesznek.

Megjegyzs: Tipikusan olyan lltsokat bizonytunk, hogy pld. egy-egy mvelet amortizcis ideje
legfeljebb O(log n), ebbl kvetkezik hogy m mvelet elvgzsnek tnyleges sszideje legfeljebb
O(m log n). De persze 1 adott mvelet elvgzsnek tnyleges ideje lehet akr c n is, ezrt az
amortizcis elemzssel garantlt lpsszm adatstruktra nem hasznos vals idej folyamatokban
(pld. egy replgp navigcis rendszertl nem azt vrjuk, hogy tlagosan gyorsan dntsn, hanem
azt, hogy minden egyes vszhelyzetre azonnal reagljon). Azonban egy algoritmus teljes futsa sorn
vgrehajtott adatstruktra-mveletek sszidejre a fentiek alapjn korrekt becslst kapunk.
Megjegyzs: Persze korrekt becslseket kapunk nemcsak az sszidre, hanem minden m0 < m esetn az
els m0 mvelet sszidejre is (a fenti pldban O(m0 log n)).

Az elz pldra alkalmazva: legyen a P potencil az adott pillanatban az 1-esek


szma. Ekkor kezdetben ez 0. Ha egy NV mvelet sorn az utols k jegy 1-es, akkor a
mvelet tnyleges ideje k + 1 lesz. A potencilvltozs pedig P = k + 1. Teht egy
NV mvelet amortizcis ideje AI = (k + 1) + (k + 1) = 2.
5.1.1. Amortizcis id s a strigulzs kapcsolata
Amikor egy mveletet vgznk, akkor kapunk a mvelet megengedett amortizcis idejnek megfelel $-t. Ha az algoritmust kevesebb Lpsbl tudjuk vgrehajtani, akkor a
maradkot berakjuk a bankba. Ha viszont tbb Lpsre van szksgnk, akkor a klnbzetet ki kell vennnk a bankbl.
FIZETS

IIIIIIIII
IIIIIIII IIII
AI'

BANK

TI<AI
TI'-AI'

IIIII

AI-TI

TI'>AI' -(TI'-AI')

Kell: A bank pnze ne mehessen le negatvba. Ezt pont azzal biztostjuk, hogy megkveteljk, hogy P 0 legyen, ugyanis egy adott pillanatban a bankban lev pnz ppen az
aktulis potencil.

5.2. Konvex burok keresse


Adott: pi = (xi , yi ) R2 (1 i n) pontok a skban.
Feladat: A pontok konvex burknak megtallsa (a rajta lv cscsok felsorolsa pozitv
irny bejrs sorrendjben).
F tmb
(x2,y2)
(x k+1,y k+1)

(x1,y1)

(x k,yk)

A tmb

36

Megolds:
I. Rendezzk a pontokat xi -k szerint (x1 x2 xn ).
Id: O(n log n).
II. Egy adott ciklusban tudjuk a p1 , . . . , pi1 pontok konvex burkt, kln troljuk
balrl jobbra rendezetten az F fels s az A als vet.
for i = 2..n
Felez keresssel az als s a fels ven vgigmenve megkeressk az ugrpontot (az
utols olyat, ami mg a p1 , . . . , pi halmaz konvex burkn is rajta van)
A s F tovbbi rszt elfelejtjk, majd vgkre rakjuk pi -t. (Ha xi = xi1 , akkor vagy pi
rajta van az utols pontok kztti szakaszon, ekkor nincs tennivalnk, vagy pl. yi nagyobb
az F utols pontjnak y koordintjnl, ekkor csak F -et kell vltoztatnunk).
Megjegyzs: F (j) az ugrpont, ha az F (j 1) s F (j) pontokat sszekt egyenes pi felett megy,
de az F (j) s F (j + 1) pontokat sszekt egyenes mr alatta.

Id: 1 pont hozzadsa legfeljebb O(log n), gy az sszid: O(n log n).
sszefoglalva: skban a konvex burok keress O(n log n) idben megoldhat.
Itt is rdemes a msodik fzist gyorstani (pld. lehet, hogy x szerint rendezve kaptuk
a pontokat).
7. Ttel. Ha a felez keress helyett jobbrl indulunk, s sorban megvizsgljuk, hogy az
adott pont-e az ugrpont, akkor a msodik fzis ideje csak O(n).
Bizonyts:
A potencil definilsa: P := |F | + |A|.
1 Lps definilsa: F-ben az ugrpont megkeresse l + 1 Lps legyen, ha F vgrl
l cscsot trltnk ki.
(Ugyangy definiljuk a Lpseket A esetn is, ekkor l0 a trlt cscsok szma). Az elemzs
alaptlete az, hogy a kitrlt cscs mr soha nem fog szerepelni.
Amortizcis elemzs: AIi = T Ii +P = ((l+1)+(l0 +1)+1+1)((l1)+(l0 1)) = 6
Azaz egy cscs beszrsnak amortizcis ideje 6. Ez azt jelenti, hogy 6n Lpsben,
azaz O(n) idben megoldhat a feladat. Az elemzs persze attl mkdik, hogy ha egy
cscsot F -bl vagy A-bl kidobunk, akkor azzal ksbb mr sose kell foglalkoznunk, hiszen
mr az aktulis ponthalmaz konvex burknak is bels pontjai. sszesen persze a kt
tmbbl kevesebb mint 2n esetben dobhatunk ki pontot.

6. Fejlettebb kupacok
A kupacokat angolul egyarnt hvjk heap-nek s priority queue-nak, azaz prioritsos
sornak.

37

6.1. Fibonacci kupac


Tulajdonsgai:

Tbb kupacrendezett fbl ll, amelyekben egy cscs gyerekeinek szma nincs korltozva, s nem is kiegyenslyozottak,
a gykerek ciklikusan kt irnyban krbe vannak lncolva,
a kupacot egy H pointerrel azonostjuk, amely a minimlis kulcs gykrre mutat.
Trols:

Minden elemhez 4 pointert trolunk: szlje, bal testvr, jobb testvr, egy gyereke
(mindegy, hogy melyik gyerek: k is ciklikusan kt irnyban krbe vannak lncolva,
gy gyorsan (lineris idben) vgigjrhatjuk ket).
r(v) N: a v elem rangja (a gyerekeinek a szma).
m(v) {0, 1}: jell bit.

Mveletek:
Beszrs(H,j):

A gykerek kz j gykrknt (1 pont fa) felvesszk j-at.


Ha K(j) < K(H), akkor a H-t az j-ra lltjuk.
j elem

Id: O(1).
A Mintrlshez szksgnk lesz az albbi bels mveletre:
LINK(u, v) mvelet:
Ha K(u) K(v), akkor v-t ktjk u al s u rangjt nveljk eggyel, klnben u-t v al
(ebben az esetben v rangja n eggyel). Visszaad egy pointert arra a cscsra, amely gykr
maradt. Egy LINK mvelet ideje: O(1). Az 1 Lpst gy definiljuk, hogy belefrjen kt
LINK mvelet s mg nhny adminisztrcis lps.
38

Mintrls(H):

M IN := H, a vgn return(M IN ).
I. fzis: H-t kivesszk, helyre befzzk a gyermekeit, s ezek szl pointereit nil-re
lltjuk.
II. fzis: Amg ltezik 2 azonos rang gykr, addig LINK mvelettel sszekapcsoljuk
ezeket.
III. fzis: vgigmegynk a gykereken s a minimlis kulcs gykrre lltjuk H-t.

Megjegyzs: A rangra nem ktttnk ki direkt fels korltot. De magtl igaz lesz, s ezt
a vgn bizonytani fogjuk, hogy minden cscs rangja legfeljebb R = O(log n). (Emlkeztet:
n a kupacban trolt elemek szmra fels becsls.)
I. fzis ideje:
a gyerekek befzse a gykerek listjba konstans idben megy, a szl pointerek nil-re
lltsa R = O(log n) lpsben (H-nak legfeljebb R gyereke lehet).
II. fzis megvalstsa:
T segdtmb segtsgvel: T [0 : R].
T indexelse a rangokkal, T (i) rtke: mutat egy i rang gykrre, ha van az eddig
vizsgltak kztt, nil klnben.
Az algoritmus:
for i = 0 . . . R
T (i) := nil / Ez itt fontos! Minden Mintrlsnl jra hasznljuk.
for v gykerek / ld az albbi megjegyzst.
w := v
while T (r(w)) 6= nil
w :=LINK(w, T (r(w)))
T (r(w) 1) := nil
T (r(w)) := w
Id: T I = O(log n) + #LINK.
Megjegyzsek: A gykereken gy lpdelnk vgig, hogy a H pointert ideiglenesen az els fzisban
egy tetszleges gykrre lltjuk (pl. a kitrlt H bal testvrre, vagy utols gyerekre), majd H-t
egy v gykr sorravtelekor annak jobb testvrre tlltjuk. Azonban valahogy szre kell vennnk,
hogy krbertnk, s ez azrt nem egyszer, mert ciklikusan lncolt listnk van, s a kezd gykeret
pedig lehet, hogy egy LINK mveletnl kiszedtk a gykerek kzl. Taln a legegyszerbb megolds
az, hogy ha a LINK mveletet kt identikus pointerrel hvjuk, akkor kiszllunk a ciklusbl.
Egy adott ilyen LINK-elsi sorozat elemzshez clszer bevezetni egy ideiglenes Q potencilt,
legyen Q a fele a tmbben lev nil pointerek szmnak. Elg beltni, hogy erre nzve ezen algoritmus
amortizcis ideje O(log n) + #LINK. Az inicializlsnl a Q potencil legfeljebb (R+1)/2-vel n,
a Lpsek szma (R + 1)/2, teht az amortizcis id R + 1 O(log n). A fciklus egy
lefutsnak amortizcis ideje 0, ha nem vgznk LINK-elst, mivel Q fllel cskken, s a tnyleges
id bven belefr fl Lpsbe. Ha a while ciklusban k 1 db. LINK-elst vgznk, akkor a Q potencil
(k1)/2-vel n, a tnyleges id k/2, gy az amortizcis id legfeljebb k.

39

A II. Fzis vgn legfeljebb R + 1 darab gykr marad. (Minden lehetsges ranghoz
legfeljebb 1.)
III. fzis ideje: Legfeljebb R sszehasonltssal, gy O(log n) Lpsben megy.
Ezeket sszeadva: T I = O(log n) + #LINK.
1. potencil (ksbb vltoztatnunk kell mg): gykerek szma
Beszrs: AI = O(1) + 1 = O(1).
Mintrls: AI (O(log n) + #LINK) + (1 + R #LINK) = O(log n).
Megjegyzs: A LINK-elsek utn az albbi alak n. kanonikus fk (vagy msnven binomilis
kupacok) keletkeznek (mindaddig, mg csak Beszrs s Mintrls mveleteket vgeztnk).
1. rang

2. rang

3. rang

Kulcs-cskk :(H, v, ): (1. Vltozat)


v-t gykerestjk (levgjuk a szljrl s befzzk a gykerek listjba, a szl rangjt
eggyel cskkentjk), majd:

K(v):=K(v) -
if K(v) < K(H) then H := v

Ennek a lpsnek a tnyleges ideje 1 Lps, az amortizcis ideje 2 Lps.


Ltszlag kszen vagyunk, de van egy nagy baj: gy nem marad igaz, hogy a rang
legfeljebb O(log n).
Szeretnnk: ha r(v) = r, akkor v-nek van legalbb cr (c > 1) leszrmazottja (ami
persze max. n lehet). Ez Kulcs-cskk nlkl mg teljeslne, de gy nem teljesl: ha
minden unokra hvnak egy-egy Kulcs-cskk mveletet, akkor v-nek sajt magn kvl
csak a gyerekei maradnak meg leszrmazottnak, mg rangja nem vltozik:

Megolds: m(v) jelzbit hasznlata:

Ha gykr: 0 (gykerestskor visszalltjuk 0-ra, ha nem az volt).


Ha v nem gykr s levgtuk egy gyerekt, akkor m(v) := 1.
40

Kaszkd-vgs: addig vgunk, amg a szljnek jelzbitje nem 0. (Utna ezt a 0-t
1-re lltjuk, ha nem gykren van.)
v
0

v
1

1
1

1
v

Teht a Kulcs-cskk vgleges megvalstsa:


Kulcs-cskk :(H, v, ):
v-t gykerestjk, majd:

A Kaszkd-vgst hajtjuk vgre, addig, amg az utoljra gykerestett cscs szlje


jelletlen nem lesz, s a vgn ezt a szlt megjelljk, ha nem gykr.
K(v):=K(v) .
if K(v) < K(H) then H := v.

Az elemzshez egy j potencilt kell definilni:


2. (Vgs) Potencil: #gykerek +2 #jellt cscsok.
A Beszrsnl s Mintrlsnl a jelltek szma nem n, teht itt a potencilvltozs
nem lehet tbb, mint az els Potencillal (H gyerekeinek gykerestsekor nhny jelzbit
0-ra vltozhat). Ezrt az ilyen lpsek amortizcis ideje nem ntt.
Kulcs-cskk : k db vgs van a kaszkdvgs sorn, ekkor legalbb k 1 helyen 0-ra
vltozott meg a jellbit, mg 1-re csak legfeljebb 1 helyen.
T I = k (Lps),
P 2(k 1) + k + 2 = 4 k.
(Mivel a jellbitek szma legalbb (k 1)-gyel cskken, k j gykr lesz s a vgn
lehet egy j jellt cscs.)
AI = T I + P 4.
Most beltjuk, hogy a rang nem lehet tl nagy:

y1

y2

yr(x)

Egy tetszleges idpontban indexeljk az x cscs y1 , . . . , yr(x) gyerekeit a gyerekk vls


sorrendjben (azaz, hogy mikor lett utoljra x gyereke).
14. llts. r(yi ) i 2

41

Bizonyts:
Amikor yi az x gyereke lett (utoljra):
LINK mveletet vgeztnk, teht rangjuk egyenl volt. Teht ekkor a rangjuk legalbb i 1 volt (x-nek ekkor gyerekei voltak y1 , . . . , yi1 ), s azta yi rangja csak egyet
cskkenhetett, klnben levgtuk volna x-rl.
3. Definci. Sk jellje azt, hogy egy legalbb k-adrang cscsnak minimum hny leszrmazottja lehet (brmikor).
Megjegyzs: minden elem leszrmazottja sajt magnak. S0 = 1, S1 2.

8. Ttel. Sk

k2
X

Si + 2

i=0

Bizonyts:
x

y1

y2
S0

yi

yk

Si-2

Sk-2

Fibonacci szmok: F0 = 0; F1 = 1; Fn+2 = Fn+1 + Fn


15. llts. Sk Fk+2 .
Bizonyts: Indukcival
trivilis.

Legyen = 5+1
.
Tudjuk,
hogy
2
k
k
Fk+2 , ebbl Sk .
Emlkeztet: n jelli a kupacban szerepl elemek maximlis szmt. Teht brmely
v elemnek legfeljebb n leszrmazottja lehet, gy r(v) log n 1, 44 log n. Ez lesz R
rtke.
Azaz belttuk, hogy a Fibonacci-kupaccal:
n db Beszrs
n db Mintrls
m db Kulcs-cskk
sszes ideje: O(n log n + m).
Ebbl kvetkezik:
9. Ttel. A Dijkstra s Prim algoritmus lpsszma Fibonacci-kupaccal O(n log n + m).
Megjegyzsek.
A Dijkstra-ban semmilyen adatstruktrval nem lehet ez al lemenni (mivel tud rendezni, pl.
egy csillag leire rjunk ai slyokat; msrszt sszefggsget is el tud dnteni).
A Prim-nek is ez a legjobb futsi ideje (ugyanezrt), de minimlis kltsg fesztfa keressre
m < n log n esetn ismernk gyorsabb algoritmust (rdekes mdon az is a Fibonacci-kupacon
alapul).

42

6.1.1. Szigor Fibonacci-kupac


2012-ben Brodal, Lagogiannis s Tarjan megcsinltk a Fibonacci-kupac olyan vltozatt
is, ahol ugyanazok a mveleti idk rhetk el, de nemcsak amortizlt, hanem legrosszabb
id vltozatban is, teht minden egyes mvelet legrosszabb esetben megy konstans idben,
kivve a Mintrlst, ami O(log n) idben.
Ez a struktra is a Fibonacci-kupacon alapul, a vltoztatsok lnyege a kvetkez:
A kupac-rendezett fkat egyetlen kupacrendezett fban troljuk, s itt segt, hogy
feltesszk, hogy a kulcsok klnbzek, teht igazbl a (KULCS, nv) prokat lexikografikusan rendezzk.
A fa cscsai lehetnek aktvak s passzvak. Egy cscs aktv gykr, ha aktv, de
szlje passzv (lnyegben ezek felelnek meg a Fibonacci-kupac gykereinek). A rang
az aktv gyerekek szma. A jell-bit helyett minden aktv cscsra nyilvntartunk egy
nemnegatv VESZTESG rtket.
Legyen R = 2 log n + 6, ez lesz a fels korlt az aktv cscsok rangjra. A kvetkez
(helyenknt ravasz) invarinsokat tartja fent az algoritmus:
A gykr passzv.
Aktv gykr vesztesge 0.
Egy aktv cscs i-edik aktv gyereknl a rang s a vesztesg sszege legalbb i 1.
Az aktv gykerek szma legfeljebb R + 1.
A vesztesgek sszege maximum R + 1.
A p-edik cscs gyerekeinek szma maximum 2 log(2n p) + 10.
A rszletek az eredeti cikkben olvashatk, amely elrhet a segdanyagokban.

6.2. Prosts kupacok


Ami miatt a Fibonacci-kupac a gyakorlatban ritkn hatkony:

nagy helyigny (sok pointer),


1 Lps elg sok kis elemi mveletbl ll.

Ezrt most definiljuk a Prosts kupacot, amely a gyakorlatban ltalban gyorsabb,


mint a Fibonacci, fleg a ksbb lert lustbb vltozat. Azonban nem talltak hozz
olyan potencilt, amivel be tudnk ltni ugyanazokat az amortizcis idket, mint a
Fibonacci-kupacnl, st, ksbb kiderlt, hogy ilyen nem is ltezhet.
tlet: A Fibonacci-kupacot akarjuk utnozni, de binris fval s kevesebb pointerrel.
Elszr emeljk fel a H gykeret s helyre fzzk be a gyerekeit. Majd forgassuk el 45
fokkal az egszet, ez lesz a prosts kupac. Teht itt a bal gyerek felel meg az els
gyereknek, a jobb gyerek a jobb testvrnek.

43

v
a
a

A prosts kupac defincija:

Binris fa.
A gykrnek (ami H-nak felel meg) nem lehet jobb gyereke.
Flig kupacrendezett: K(v) K(x) a v bal finak minden x leszrmazottjra.

gy cscsonknt akr 2 pointert is nyerhetnk, ha hasznljuk mg a binris fk memriatakarkos megvalstst: cscsonknt 2 pointer s 1 bit, mely azt jelli, hogy bal
vagy jobb gyerek (ez a bit egybknt is hasznos, ltni fogjuk, hogy binris fkban sokszor
fontos ez az informci).

1. pointer:

bal gyerek, ha ltezik


jobb gyerek, ha csak az ltezik.
nil: ha egyltaln nincs gyereke.

2. pointer:

ha maga bal gyerek, akkor a testvrre mutat, ha ltezik, klnben a szlre.


Ha jobb gyerek: a szlre mutat.
Gykrben nil.

Knny Hf: egy eredeti pointer szerinti mozgshoz gy kt lps (+vizsglat), s esetleg
egy harmadik kiolvass s vizsglat kell.
Vissza a prosts kupachoz: definilnunk kell mg a mveleteket.
LIN K mvelet: (ha pld. K(x) K(y))
y
y 3

x 4
a

x
LINK

Id: O(1).

44

Kupacmveletek :
Ekkor T I = O(1).

Beszrs: 1 elem j kupac + LINK.


Kulcs-cskk :

kivgjuk az elemet a bal finak leszrmazottaival egytt,


cskkentjk a kulcsot,
majd LINK. T I = O(1).

Mintrls:

vgs
8

7
2
6
3
5
v

A gykeret levgjuk, majd az j gykrtl jobbra lefel haladva minden let elvgunk. gy sok kisebb prosts kupacunk keletkezik. ssze kell LINK-elni a sztvgott
kupacokat.
A leghatkonyabb megolds: Elindulunk lefel s prosval sszeLINKeljk a kupacokat, majd ezutn alulrl felfel haladva vgznk LINK-elseket (mindig a kvetkezt az
elz eredmnyhez).
Mirt ez a legjobb? Az a rossz, ha a kt linkelend kupacnak nagyon eltr a mrete. Az
a j, ha kb. egyenl nagysgakat linkelnk, ezt prbljuk elrni. Msrszt vegyk szre,
45

hogy az els fzisban egy tfelezsnek megfelel dolgot csinlunk, melynek hatkonysgt
mr lttuk.
P
Ami bizonythat: a P = v log(#v leszrmazottai) potencillal O(log n) az amortizcis ideje minden mveletnek.
Azonban a gyakorlati futtatsok sokig azt mutattk, hogy igazbl a Kulcs-cskkentsek
tlagos ideje konstans. Fredman 99-ben megmutatta. hogy ez mgsem igaz, konstrult
olyan mvelet-sorozatokat, melyekben tlagosan log log n id kell a Kulcs-cskkentsekhez.
6.2.1. A prosts kupacok hatkony vltozata
tlet: Mg lustbban. Nem j kicsiket sokkal nagyobbakkal LINK-elni. Ezt tipikusan a
Beszrs s Kulcs-cskk mveleteknl tesszk. Ezrt ennl a kt mveletnl LINK-els
helyett egy kln segdterletre rakjuk ket.
segdterlet

Beszrs

Beszrs

. . .

A segdterletet trolhatjuk a gykr jobb leszrmazottaiknt. Most a Mintrlsnl kell


egy kicsit tbbet dolgoznunk.
Mintrls:

Elszr a segdterleten vgznk LINK mveleteket. Prosval keletkezsi sorrendben LINK-elnk, majd jra ellrl prosval, mg az egsz segdterlet 1 kupac nem
lesz.
sszelinkeljk az eredeti s a segdkupacot.
Majd hagyomnyos Mintrls.

6.2.2. A prosts kupacok legjabb vltozatai


Elmasry 2009-ben mutatott be egy olyan vltozatot, ahol a mveletek bizonythat amortizcis ideje O(log n), ezen bell a Kulcs-cskkents O(log log n). A f tlet a kvetkez: kln segdterleten troljuk a Beszrsok 1 cscs fit, s egy msikon a Kulcscskkentseknl kivgott fkat, valamint egy pointert a minimlis kulcs gykrre. Mintrls utn, illetve, ha a msodik segdterleten lev fk szma elrte a log n-et, akkor
mindent sszefznk egy kupacc. Az 1 cscsakat gy, mint elbb, a nagyobbakat viszont gy, hogy elszr rendezzk a gykereket, majd cskken sorrendben sszelinkeljk
ket. gy vgl a mvelet eltti gykerek a vgs gykrtl szigoran balra men ton
lesznek.
Haeupler, Sen s Tarjan szintn 2009-ben vezettk be a Rang-prosts kupacokat. Ebben minden mvelet ugyanannyi idben (amortizlt) megy, mint a Fibonacci kupacban,
46

de lnyegben megtartja a prosts kupacok elnyeit, gy a gyakorlatban is gyors. Minden


cscshoz nyilvntartunk egy rangot. A Beszrsoknl, Kulcs-cskkentseknl minden a
segdterletre kerl, a Mintrlsnl az elejn (jobbra men lek sztvgsa sorn) keletkez kisebb kupacokat is ide rakjuk. Viszont linkelni csak azonos rang gykereket szabad,
ilyenkor az j gykr rangjt eggyel nveljk. A rangra azt a tulajdonsgot kell fenntartani, hogy egy u cscs gyerekeinl mindig igaz legyen, hogy vagy mindkett rangja eggyel
kisebb, mint u rangja, vagy pedig az egyik ugyanannyi, a msik kisebb (akrmennyivel). Emiatt a Kulcs-cskkentseknl a kivgs utn esetleg felfel ezt a tulajdonsgot ki
kell javtani. Ezzel egytt is kijn a konstans amortizcis id a Kulcs-cskkentsre s a
Beszrsra, s a Mintrls amortizcis ideje is marad O(log n).

6.3. r-kupacok
Ha a kulcsok kis egszek, akkor tudunk jobb kupacot is csinlni. A naiv megkzelts
a vdrs kupac: ha a kulcsok egszek a [0, C] intervallumbl, felvesznk C + 1 vdrt a
kulcsokkal megcmkzve. Egy i cmkj vdrbe rakjuk az sszes olyan rekordot, melynek
kulcsa i. Ezeket egy ktszeresen lncolt listban troljuk (minden vdrhz). Beszrsnl
berakjuk a megfelel vdrbe (a lista elejre, O(1) lps), Kulcs-cskkentsnl kifzzk
(ezrt kell ktszeresen lncolt lista), cskkentjk, az j vdrbe berakjuk (ez is O(1)
lps). A Mintrlsnl a nehzsg az els nem-res vdr megtallsa, a tbbi knny,
gy a Mintrls ideje legrosszabb esetben O(C) lps. Ez gy egsz jl mkdik a Prim
algoritmusra, ha a kltsgek egszek a [0, C] intervallumbl (O(m + nC) sszes lpsben,
de ksbb sokkal jobbat fogunk csinlni). Azonban a Dijkstra algoritmushoz gy nem
igazn j, mivel ilyen kltsgek esetn a kulcsok akr (n 1)C nagysgak is lehetnek. A
Dijkstra algoritmus tulajdonsgait kihasznlva ez is levihet O(m + nC) lpsre: vegynk
nC vdrt, s vegyk szre, hogy a 6. ttel miatt kt egyms utni Mintrls esetn a
msodiknl nagyobb a minimlis kulcs, de legfeljebb C-vel. gy egy Mintrlsnl legfeljebb
C jobbra lps utn (az elz Mintrls kulcsa szerinti vdrtl indulva) tallunk nem
res vdrt. Most ezen fogunk lnyegesen javtani.
Teht legrvidebb utakat keresnk, s feltesszk, hogy az lek hossza a [0, C] tartomnybeli egszek, azaz a kulcsok a [0, (n 1)C] tartomnyban lesznek.
Monoton kupac tulajdonsgai:

Mintrlsek kulcsai az id elrehaladtval monoton nnek


Ha az utols Mintrlskor a kulcs dmin , akkor az sszes aktulis kulcs eleme a
[dmin , dmin + C] tartomnynak.

Megjegyzs: a 6. ttel miatt a Dijkstrnl hasznlt kupac ezeket teljesti, teht monoton.

Monoton kupacokat, ha C nem tl nagy, az gynevezett r-kupacokkal (r = radix, ill.


redistributable) rdemes megvalstani.
Legyen c = dlog(C + 1)e + 2.
u1
B1

u2
B2

u4

u3
B3

B4

47

u5
B5

Vdrk:
B1 , B2 , . . . , Bc vdrket ksztnk. A Bi vdrhz az ui fels korltot s a range(Bi )
szmintervallumot rendeljk. Egy Bi vdrbe azokat az elemeket rakjuk, amelyek kulcsa
eleme a range(Bi )-nek.
range(Bi ) = [ui1 + 1, ui ].

mindig igaz lesz: |range(Bi )| 2i2 , ha i = 2, . . . , c 1 s |range(B1 )| = 1,


|range(Bc )| nC + 1. Az ui sorozat mindig monoton nv lesz, de nem szigoran,
gy menet kzben lehet olyan i, hogy range(Bi ) = .

Kezdetben gy lltjuk be az rtkeket:


u0 = -1
ui = 2i1 1
uc = nC (ebbe a vdrbe biztosan belefr minden elem)
range(B1 ) = [0]
range(B2 ) = [1]
range(B3 ) = [2, 3]
range(B4 ) = [4, 5, 6, 7]
..
.
Cl : A kupac elemeit gy trolni, hogy v a Bi -ben legyen, ha K(v) range(Bi ). Egy
vdr tartalma egy oda-vissza lncolt lista lesz.
Mveletek :
Beszrs(v):
Itt megkereshetnnk felez keresssel is a megfelel vdrt, azonban, mint a konvex
burok keressnl mr tapasztaltuk, az rosszabb megoldst adna.
for j = c . . . 1 (1)
if uj1 < K(v) then v Bj ; j := 0
Megjegyzs: 1 elem beszrsnak tnyleges ideje O(c) = O(log C).

Kulcs-cskk(v, j, ): (hvskor nemcsak v cmt, hanem az t tartalmaz vdr sorszmt


is tudnunk kell)

K(v) := K(v)
if K(v) uj1 then kivesszk, elindulunk balra s megkeressk a j vdrt.

Mintrls:

Ha B1 6= tetszleges elemt trljk s visszaadjuk.


Klnben legyen Bj az els nem res vdr. Vgignzzk a Bj vdr minden elemt.
Legyen v az egyik minimlis kulcs, dmin := K(v).
tcmkzzk ui -ket:
u0 := dmin 1
u1 := dmin
ui := min(ui1 + 2i2 , uj ), ha i = 2, . . . , j 1.
48

Majd Bj minden elemt (egyesvel balra mozgatva) berakjuk a neki megfelel vdrbe, kivve v-t, amelyet trlnk.

16. llts. Ezutn Bj minden elemnek a helye Bi lesz valamilyen i < j-re, azaz a Bj
vdr kirl.
Bizonyts: Mivel a Bj eltti vdrk resek voltak, az tcmkzs leglis. Mivel a
mvelet vgrehajtsa eltt dmin range(Bj ), ezrt dmin uj 2j2 + 1. Emiatt az
tcmkzsek utn uj1 = min(uj , dmin +1+2+ +2j3 ) = min(uj , dmin +2j2 1) = uj .
gy minden elemet tnyleg balra kell mozgatni, mivel range(Bj ) res lett. Mivel Bj ben semelyik elem kulcsa nem kisebb, mint dmin , mindenkit jl el tudunk helyezni. (A
|range(Bi )| rtkek nyilvn teljestik a megkvnt fels korltokat minden i j-re, mshol
pedig nem vltoztatjuk ket.)
Amortizcis elemzs
X
A potencil : P =
b(v),

ahol b(v) a v-t tartalmaz vdr sorszma.

vkupac

Egy Lps legyen (elszr) 1 elem eggyel balra traksnak ideje (kivesszk, ellenrizzk,
hogy oda val-e, berakjuk).
Mveletek:
Beszrs(v): T I = (c + 1 b(v))
P = b(v)
gy AI = c + 1.
Kulcs-cskk : T I = 1 + (b(v) buj (v))
P = buj (v) b(v).
Teht AI = 1.
Mintrls: Ha B1 nem
AI = 0. Egybknt:
 volt res,
X akkor nyilvn

T I = j + |Bj | + j + 1 +
j buj (u) , ahol
uBj ,u6=v

j: Bj , az els nem res vdr megkeresse


|Bj | = a j. vdrben lev elemek szma: vgignzzk Bj tartalmt s kivlasztjuk
v-t,
j: ui -k tcmkzse,
utols tag: balra pakolsok ideje (a szumma eltti 1+ a v kihagysra fordtott
id).
Megjegyzs:

(j buj (u)) |Bj | 1, mivel (j buj (u)) 1 minden u-ra a 16. llts

uBj ,u6=v

miatt.

Egy j Lps := 2 Lps (teht ktszer annyi elemi lps), gy


X

T I j + |Bj |/2 + 1/2 + (1/2)
j buj (u) j + 1 +

X
uBj ,u6=v

uBj ,u6=v

49


j buj (u)

Mivel P = j


j buj (u) , ezrt AI 1.

uBj ,u6=v

Teht
s n0 n Mintrlst vgznk,
P ha pldul
P n Beszrst, m Kulcs-cskkentst,
0
akkor:
TI
AI n (c + 1) + m + n n (log C + 4) + m darab Lps, gy
O(m + n log C) sszes futsidt kapunk (ha C 2). Teht a Dijkstra futsi ideje
[0, C]-beli egsz hosszak esetn r-kupaccal: O(m + n log C).

6.4. Thorup kupaca


Ennl a kupacnl is jobbat ksztett Thorup, legalbbis elmletileg (gyakorlati megvalstsrl s tesztekrl nem tudunk):
Az n. word RAM modellen dolgozunk: legyen w = a szhossz az adott gpen (azaz
egy memria cellba legfeljebb w bites szmok frnek). Feltesszk, hogy w log n, s
w log C, ahol C a hosszak maximuma (a hosszak itt is nemnegatv egszek). Teht
azt tesszk fel, hogy minden lhossz s egy cscs neve belefr 1 szba. Valamint feltesszk, hogy 1 Lpsben 2 sz sszege s szorzata kiszmolhat (ezeket a jegyzet utols
fejezeteiben is fel fogjuk tenni).
Ezen feltevsek mellett Thorup kupaca a Beszrst s Kulcs-cskkentst O(1) idben,
a Mintrlst pedig O(log log min(n, C)) idben elvgzi, radsul nem csak amortizcis
idben, hanem garantltan minden egyes mveletnl.
Ezzel a kupaccal a Dijkstra O(m + n log log min(n, C)) idej lesz.

7. Sztrak
Legyen adott egy U univerzum s egy ezen a halmazon rtelmezett < rendezs.
Feladat: adatstruktra ksztse S U elemek trolsra. S (a pillanatnyi sztr)
minden elemt csak egyszer troljuk.
Megjegyzs: Igazbl persze legtbbszr nemcsak magt az s sztr-elemet kell trolni, hanem s
mell vagy egy pointert is az s kulcs rekordra; vagy, amennyiben ez a rekord az s-en kvl csak a
j(s) jelentst tartalmazza, akkor ezt a j(s) szt is. Ezt a tovbbiakban nem rszletezzk, de az s
helynek megkeresse pont azt jelenti, hogy ezt is meg kell tallnunk.

Mveletek :
Keress(x, S):

Knnytett: x ?S
Nehezebb: keressk meg x-et ha x S, klnben pedig N IN CS.

Ha egy sztr csak ezt az egy mveletet tudja megvalstani, akkor statikus sztrnak
nevezzk.
Ha a sztr nem statikus, akkor a msodik legfontosabb mvelet a
50

Beszrs(x, S):

Knnytett: garantlt, hogy x


/ S, s beszrjuk. (S := S + x)
Nehezebb: ha x
/ S, akkor S := S + x.
Ha egy adatstruktrban mindkt mvelet megoldott, akkor sztrrl beszlnk.

Trls(x, S):
Ha x S, akkor S := S x.
Ha mindhrom mvelet megoldott, akkor az adatstruktra sztr trlssel.
Ezen mveleteken kvl az albbi mveletek is hasznos kiegsztk lehetnek:

min(S)
max(S)
Kv (S, a): visszaadja a-t, ha a S, klnben pedig a legkisebb b S sztrelemet,
melyre b a.
Tlig (S, a, b): {x S | a x b}
Fsl (S1 ,S2 ): Tudjuk, hogy S1 S2 = . Legyen S := S1 S2 .
Olvaszt (S1 , a, S2 ): Tudjuk, hogy S1 < a < S2 . Legyen S := S1 {a} S2 .
Sztvg (S, a): Sztvgja S-et olyan S1 s S2 -re, hogy S1 < a < S2 .

Sztrak megvalstsa: Ha |U | kicsi: trolhatjuk karakterisztikus vektorban pointerekkel az elemeket. Az indexek U elemei lesznek. Persze ha U nem a [0, |U |1] termszetes
szmokbl ll, akkor kell egy h fggvny, mely U elemeit ezekbe kpezi, legtbbszr ilyet
knnyen konstrulunk; de elfordulhat az is, hogy nem, ekkor sokszor rdemesebb az
ltalnos esetre vonatkoz algoritmusok egyikt hasznlni.
Mostantl feltesszk, hogy |U | nagy.
Statikus sztrak esetn: S elemeit rendezett tmbben trolhatjuk s felez keresst
hasznlhatunk. Ltni fogjuk, hogy ennl az ltalnos megoldsnl sokszor jobbat is tallunk.
x<?T[n/2]
i

x<?T[n/4]
i

. . .

. . .
. . .

51

7.1. Binris keresfa


Ez a felez keress nyilvnval ltalnostsa. Kt vltozatt ismerjk, az irodalomban
tbbnyire a msodik vltozat szerepel.
1. Kls trols: a fa leveleiben vannak a rekordok, a tbbi cscsban pedig U elemei
szerepelnek tjelzkknt, a v cscsban trolt tjelzt u(v) jelli, s az a jelentse,
hogy az ennl kisebb-egyenl elemeket a bal gyerek rszfjban, a nagyobbakat a
jobb gyerek rszfjban kell tovbb keresni. A Keress eljrstl klnbz visszatrsi rtkeket vrunk. Elszr is egy logikai rtket, hogy a keresett sz szerepel-e
a sztrban. Ha igen, akkor a helyre is szksgnk van. Ha nem szerepel, akkor is vrunk valami helyre vonatkoz visszatrsi rtket, amire a Beszrsnl lesz
szksgnk (statikus sztrnl ez felesleges). Meghvsnl a keresend szn (x) kvl megadjuk a sztr nevt is, ami a gykrre mutat r pointer. Kls trols
sztrnl feltesszk, hogy nincsen egy-gyerekes cscs (mivel felesleges lenne; ezt a
tulajdonsgot persze fent is kell tartanunk).
Megjegyzs: A levelekben balrl jobbra haladva S elemei rendezve vannak.

Keress(x, r):
v := r
while bal(v) 6= nil
if x u(v) then v := bal(v)
else v := jobb(v)
if x = u(v) then return(V AN, v, bal)

/ mindegy, hogy jobb vagy bal, V AN esetn

nem hasznljuk

else if x < u(v) then return(N IN CS, v, bal)


else return(N IN CS, v, jobb).
2. Bels trols: a fa minden cscsban trolunk egy rekordot (megfeleltethetk S
elemeinek). A keress sorn 3-fel elgaz if van, amit direktben elg kevs nyelv tmogat (pld. FORTRAN). Elnye viszont, hogy kevesebb trhelyet foglal (kb. felt).
Az elemzsek cljbl a fa minden egy-gyerekes cscsa al kpzeletben odarakunk
egy, minden levele al pedig kett fiktv levelet. Ezeket nem troljuk, de a definciknl s elemzseknl hasznosak lesznek.
s

s'

52

Keress(x, r):
v := r
repeat
if x = u(v) then return(V AN, v, bal) / bal-jobb mindegy
if x < u(v) then
if bal(v) 6= nil then v := bal(v)
else return(N IN CS, v, bal)
else / x > u(v)
if jobb(v) 6= nil then v := jobb(v)
else return(N IN CS, v, jobb)

A bels s kls trols fk sszehasonltsa (abban az esetben, ha teljesen kiegyenslyozott):


Kls
Memria 2n 1 kulcs +n rekord,
s 6n 3 pointer
Mlysg dlog ne
Keress
dlog ne + 1 sszehasonlts

Bels
n kulcs +n rekord,
s 3n pointer
dlog(n + 1)e 1
dlog(n + 1)e sszehasonlts, de 3 irny!

Bizonyos alkalmazsoknl nhny elemet sokkal tbbszr keresnk, mint msokat.


Bels trols fknl, ha ezeket kis mlysgben troljuk, akkor sokat nyerhetnk.
Megjegyzsek.
A hrom irny sszehasonlts a legtbb krnyezetben 2 lps lesz!
Az esetek tlnyom rszben bels trols keresft fogunk hasznlni, mert az irodalomban
gy szoksos.

7.1.1. Mveletek ltalnos binris keresfban


Keress(x, r): lsd fentebb.
Beszrs(x, r): Elszr Keress(x, r).

Kls trolsnl: ha x
/ S, akkor megkapunk egy v levelet s egy irnyt. Ltrehozunk v helyre egy j w cscsot, az irnytl fggen x vagy u(v) tjelzvel, az
irny szerinti gyereke egy x-et tartalmaz levl lesz, a msik gyereke pedig v.
Bels trolsnl: ha x
/ S, akkor megkapunk egy v cscsot s egy irnyt (ez gy
egytt egy fiktv levl neve). Ltrehozzuk a v cscs irny szerinti gyerekt, s ebbe
a levlbe troljuk le x-et.

Trls(x, r):

Kls: trivilis (megkeressk s kitrljk), de a testvrt felrakjuk a szlbe (ne


legyen egy felesleges tjelz tbla).
Bels: Kt esetet kln-kln vizsglunk.
53

1. eset Ha x-nek legfeljebb egy gyereke van, akkor a gyereke jn a helyre. Ekkor
az j fa is j keresfa lesz.

x
y
y

2. eset Ha x-nek 2 gyereke van:


Megkeressk az x-et kzvetlenl megelz y elemet. Ezt gy tesszk, hogy
1-et balra lpnk s utna amg lehet mindig jobbra.

xy

x-et s y-t felcserljk, majd az j x-et trljk az els mdszer szerint


(ennek mr nincs jobb gyereke).
J az algoritmus: ha trljk x-et, akkor y mr j helyen lesz, azaz nem romlik
el a keresfa tulajdonsg.
Lpsszm:

A lpsszmok legrosszabb esetben a fa mlysgvel egyenlek.


Nem tudunk semmit a fa mlysgrl!
Ha pldul n elemet szrunk be nvekv sorrendben, akkor a fa mlysge n lesz.

Clunk ezek alapjn olyan fa kialaktsa, amelynek mlysge O(log n).


4. Definci. Egy n rekordot tartalmaz binris ft (gyengn) kiegyenslyozottnak hvunk, ha mlysge legfeljebb
2 dlog(n + 1)e + 1 2 log n.

54

7.1.2. Optimlis binris keresfa


Statikus sztrat akarunk trolni gy, hogy felttelezzk, hogy rengetegszer kell majd
benne keresni. Ezen keressek sszidejt akarjuk minimalizlni.
Adottak :

S = {a1 < a2 < < an } a sztr elemei.


ai -t pi valsznsggel keressk.
ha ai < b < ai+1 , az ilyen b-ket qi valsznsggel keressk.

ha b < a1 , akkor b-t q0 , ha pedig an < b, akkor b-t qn valsznsggel keressk.

Egy adott T keresfa esetn egy keress vrhat lpsszma, melyet a fa kltsgnek
hvunk:
n
n
X
X
E(keress)=c(T ):=
pi (d(ai ) + 1) +
qi d(i), ahol
i=1

i=0

d(ai ): az ai -t tartalmaz cscs mlysge; a +1 azrt kell, mert a gykr keresse sem
0 lps.
d(i): az i. (balrl jobbra szmozva) fiktv levl mlysge.

Feladat: Minimlis kltsg binris keresfa konstrukcija, azaz olyan T , amelyre c(T )
minimlis.
Megolds: Ha ak lenne az optimlis T fa gykerben:
ak

T1
a 1 ...

T2
a k-1

ak+1 ...

an

Ha ez az optimum, akkor szksgkppen T1 s T2 is optimlis fa (a bennk szerepl ai -k


ltal meghatrozott rszfeladatra). Ez a szuboptimalits elve.
Megjegyzs: Azok a feladatok, amelyekre a szuboptimalits elve teljesl, tbbnyire megoldhatak
hatkonyan, erre val a dinamikus programozs, ahol elszr is jl definilunk rszfeladatokat, utna
ezeket a megfelel sorrendben kiszmoljuk, a rgebbi rszfeladatok megoldst jl felhasznlva.

Ti,j := optimlis fa az ai+1 . . . aj szavakon. Ennek gykere ri,j , kltsge ci,j , slya pedig
wi,j := qi + pi+1 + qi+1 + + pj + qj (wi,j az a valsznsg, hogy belpnk egy Ti,j fba).
Inicializls:
Ti,i = ; ci,i = 0; wi,i = qi .
Neknk a T0,n ft kell megkeresni. Vegyk szre, hogy ha tudnnk, hogy ri,j = k, akkor
a szuboptimalits elve miatt a Ti,j fa gykernek bal rszfja Ti,k1 , jobb rszfja pedig
Tk,j lesz. Ezrt ekkor a kltsge ci,j = (ci,k1 +wi,k1 )+pk +(ck,j +wk,j ) = ci,k1 +ck,j +wi,j
55

lesz, mivel a Ti,j fban minden cscs mlysge eggyel nagyobb, mint a Ti,k1 , ill. a Tk,j
fkban. Vegyk szre, hogy a kltsgben wi,j lland, nem fgg a k-tl.
Ezek alapjn knnyen kszthetnk egy rekurzv algoritmust:
R(i, j) :
:=
for k := i + 1 . . . j
C1 := R(i, k 1)
C2 := R(k, j)
if C1 + C2 < c0i,j then c0i,j := C1 + C2 ; ri,j := k
return(ci,j := c0i,j + wi,j )
Ez az algoritmus azrt exponencilis, mert ugyanazt a dolgot sokszor szmoljuk
ki. A hvsok szma az n. Catalan-szm lesz, ami kb. cn1n 22n . Hogy ezt elkerljk,
dinamikus programozssal fogjuk megoldani a feladatot.
c0i,j

A dinamikus programozs jellemzi:

Jl kell definilni, hogy milyen rszfeladatokat akarunk megoldani.


Amit mr egyszer kiszmoltunk, azt feljegyezzk, hogy ne kelljen mg egyszer kiszmolni.
J sorrendben oldjuk meg az egyes rszfeladatokat.
a5

a4

q3

a6

q4

q5

q6

Az algoritmus (a fenti Inicializls utn), az argmin itt azt a k rtket adja vissza, amelyre
a min felvtetik:
for l = 1 . . . n
for i = 0 . . . n l
j := i + l
ci,j := wi,j + mini<kj (ci,k1 + ck,j )
ri,j := argmini<kj (ci,k1 + ck,j )
3
Id: O(n ).

7.2. 2-3 fk
Definci (2-3 fa):

Minden nem-levl cscsnak 2 vagy 3 gyereke van (ha n > 1).


Kls trols a fa (mi ezt trgyaljuk, a bels trols vltozatot lsd pld. az [1]
knyvben).
Minden levl ugyanazon a szinten van. gy legfeljebb blog nc mlysg lesz a fa.
56

Minden nem-levl cscsban kt tjelz tblt, egy szl- s 3 gyerek-pointert trolunk.

Teht egy v cscsban troljuk a p(v) szl pointeren kvl a bal(v) bal gyerekre mutat
pointert, az u1 (v) els tjelzt, a koz(v) msodik gyerekre mutat pointert, az u2 (v)
msodik tjelzt s a jobb(v) harmadik gyerekre mutat pointert (nil, ha csak kt gyereke
van). Itt u1 (v) egy tetszleges olyan elem, hogy a bal gyerek alatti minden levlben
szerepl KULCS u1 (v), de a msodik gyerek alatti minden levlben a KULCS > u1 (v).
Az u2 (v) szerepe hasonl, ha csak kt gyerek van, akkor rtke az univerzum legnagyobb
eleme.
Egy v levlnl jellje u(v) az ott trolt rekord (sztrbeli) kulcst.
Keress(x, r):
v := r
while bal(v) 6= nil
if x u1 (v) then v := bal(v)
else if x u2 (v) then v := koz(v)
else v := jobb(v)
if x = u(v) then return(V AN, v)
else return(N IN CS, v)
Ez mindig legfeljebb O(log n) lps lesz, mivel a fa mlysge nyilvn legfeljebb log n.
Beszrs(s, r):
x

Megkeressk, hogy hov kell beszrni s-et, jellje x a keressi ton az utols nemlevl cscsot, azaz p(v)-t.
Ha x-nek 2 gyereke volt, akkor beszrjuk s-et, s gy x-nek 3 gyereke lesz, de x-ben
tlltjuk az tjelzket (mshol nem kell Hf).
Ha x-nek 3 gyereke volt, akkor sztszedjk x-et 2 darab 2 gyerekes csccs.
x1

x2

Ha x szljnek 2 gyereke volt, akkor nincs gond (csak ott kell tjelzket lltani),
ha 3, akkor ezt a cscsot is sztvgjuk s gy folytatjuk a gykr fel. Ha eljutunk a
gykrig s a gykrnek 3 gyereke volt, akkor a gykeret is kettszedjk, beszrunk
egy j gykeret, s gy n a fa magassga.
Id: O(log n)
57

Ehhez csak azt kell szrevennnk, hogy egy aktulis x kettszedsnl tudjuk, hogy ki
a szl, x neki hnyadik gyereke, s magban x-ben tudunk (ideiglenesen) 3 elhatrol
tjelzt s 4 gyerek-pointert. Ezekbl knnyen konstans idben kiszmolhat a sztszeds
utni llapot a szl j 3 tjelzjvel egytt.
Trls(s, r):

Megkeressk az s-et tartalmaz levelet s kitrljk.


Ha p(s) = x-nek 3 gyereke volt, akkor kszen vagyunk (csak x-ben kell tjelzket s
gyerek-pointereket lltanunk).
Ha nem, akkor 2 esetet klnbztetnk meg:
1. Ltezik x-nek szomszdos testvre 3 gyerekkel: elkrjk az egyiket (a felnk
est).
y

Itt pl. u2 (y) j lesz j tjelznek p(x)-ben y s x kz, x pedig rklheti p(x)
megfelel tjelzjt.
2. Ha nem ltezik, akkor x-et sszevonjuk valamelyik szomszdos (s gy ktgyerekes) testvrvel.
y

y
x

Lehet, hogy ekkor az j x szljnek lesz csak 1 gyereke, teht felfel folytatni
kell. Hogyan r vget az algoritmus?
A szl 3 gyerekes volt, s most kett maradt neki, ekkor megllhatunk.
Sikerlt elkrnnk egy 3 gyerekes szomszdos testvr egy gyerekt, ekkor
is megllhatunk.
Feljutunk egszen a gykrig, trljk az 1 gyerekes gykeret s gy cskken
a fa magassga.
Hzi feladat meggondolni, hogy ez is megy O(log n) idben, minden lehetsges esetben
knny lltgatni az tjelz tblkat s a pointereket.

58

7.3. B-fk
Tulajdonsgai:
l m
B
2

# gyerekek B (kivve ha n <


Minden nem-levl cscsra igaz, hogy:
Egy cscsban B 1 tjelz kell.
Minden mvelet a 2-3 fk mintjra megy, a lpsszm O(B logB n).

l m
B
2

).

Kls traknl hasznljk: Ezek a trolk 1 olvass sorn egy egsz lapot olvasnak
be. Az tart sok ideig, mg a fejet a megfelel lapra pozicionlja a vezrls. Az a cl, hogy
minl kevesebb lapot kelljen olvasni ahhoz, hogy megtalljuk a troln keresett adatot.
gy rdemes B-t megvlasztani, hogy a B 1 tjelz s B pointer elfrjen egy lapon. s
persze a levelekben sem egy, hanem annyi egyms utni rekordot trolunk, amennyi rfr
egy lapra.
Plda: Tegyk fel, hogy egy lapra rfr 31 kulcs s 32 pointer, illetve 10 rekord. Ekkor
ha n = 10 232 43 millird s B = 32, akkor a fa mlysge legfeljebb 8 lesz. Ha a fels 4
szintet a memriban troljuk (ez maximum 323 + 322 + 33 = 33825 lap), akkor minden
mvelet legfeljebb 5 lapolvass lesz (azaz legfeljebb 5-szr kell olvasni a winchestert).

7.4. Piros-fekete fk
Eredetk : Binris faknt trolt 2-4 fk:
x

fekete
piros

Tulajdonsgai:
0.
1.
2.
3.

Bels trols binris keresfa,


minden cscsa piros vagy fekete; a fiktv levelek s a gykr feketk,
piros cscs szlje fekete,
hogy kiegyenslyozott legyen a fa: minden x cscsra igaz, hogy brmely alatta
lev fiktv levlig vezet ton mindig ugyanannyi fekete cscs van. Ezt x fekete
magassgnak hvjuk s mf (x)-szel jelljk.

rdemes megjegyezni, hogy a fenti felttelek implicite tartalmazzk, hogy () ha egy v


cscsnak csak egy valdi gyereke van, akkor az egy piros levl (v msik gyereke egy fekete
fiktv levl, ezrt v-nek csak piros valdi leszrmazottjai lehetnek, de a 2. tulajdonsg
miatt csak egy darab).
59

10. Ttel. Egy piros-fekete fa mlysge legfeljebb 2 log(n + 1).


Bizonyts: a piros cscsok fekete szlbe val behzsval. Ekkor minden fiktv levl
mlysge ugyanaz lesz, s minden nem fiktv cscsnak legalbb kt gyereke lesz, teht a
mlysg legfeljebb log(n + 1), mert egy n cscs binris fnak maximum n + 1 fiktv levele
lehet. Mivel brmely ton maximum minden msodik cscs lehet piros, ezrt az eredeti
mlysg ennek legfeljebb a ktszerese.
Mveletek :
Keress(x, r): Ugyangy kell megvalstani, mint egy tetszleges binris fban.
Egy kiegszt bels mvelet a billents, mely minden binris keresfban rtelmezhet, s tbbszr fogjuk hasznlni :
Bill(x):
y

Bill(x )

C
A

Knny vgiggondolni, hogy ha egy ltalnos binris keresfra alkalmazunk egy Billents mveletet, akkor jra binris keresft kapunk. Azonban piros-fekete fknl ez
nem mindig lesz j, elronthatja a 2. s 3. tulajdonsgokat. Radsul egy kicsit elrontott
piros-fekete fra akarjuk alkalmazni, ami azt jelenti, hogy egyetlenegy cscsra megengedjk, hogy a 2. tulajdonsg ne teljesljn. Gondoljuk meg, hogy a kvetkez kt esetben a
Billents ilyenkor is alkalmazhat.
i) Ha y = p(x) s x is piros. Ekkor a 3. tulajdonsg nyilvn egy cscsra sem romlik el,
s tovbbra is csak egy helyen nem fog a 2. tulajdonsg teljeslni.
ii) Ha y fekete, x piros, de x testvre s y felli gyereke (az brn a B rszfa gykere)
fekete. Ekkor azonban mg t is kell sznezni x-et s y-t, hogy teljesljn a 3. tulajdonsg.
Lsd az brn, knny leellenrizni, hogy ezutn a 3. tulajdonsg valban megmarad, a
2. se romlik el sehol, st, ha x-nek a baloldali a nev gyereknl volt elrontva, akkor az
meg is javul.
y

Bill(x )

a
C

piros

a
A

fekete

piros vagy fekete

60

Beszrs(s, r): A beszrs egy fekete szn x fiktv levl (amit a Keress(s, r) visszaad)
helyre trtnik, alatta ltrejn kt j fekete fiktv levl. Ezt a cscsot (x-et) pirosra kell
szneznnk a 3. tulajdonsg fenntartsa miatt.
y

y
x

Akkor van problma, ha a beszrt x elem y szlje piros szn ha fekete, vagy nem
ltezik (x az elsnek beszrt cscs ekkor feketre sznezzk), akkor kszen vagyunk.
Ezen bell hrom esetet klnbztetnk meg:
y
x

1. eset: Ha y testvre piros. Ekkor tszneznk: y-t s testvrt feketre, y szljt


(ha nem a gykr) pirosra. Ezutn vagy kszen vagyunk, vagy y nagyszlje piros volt,
ekkor x := p(y) s folytatjuk felfel az eljrst (ez legfeljebb O(log n) lpst jelent).

y
x

2. eset: Az y testvre fekete (lehet fiktv levl is).


2a. eset: Ha p(p(x)) = z-nek az x bal-bal, vagy jobb-jobb unokja.
z

Bill( y)

D
C
A

2b. eset: Ha nem a 2a. eset ll fenn. Ekkor is elg 2 Billents:


z

x
y

x
x
D

Bill( x)

C
B

61

Bill( x)

17. llts. A 2a. esetben tett billents, ill. a 2b. esetben tett dupla billents utn rendben
van a fa.
sszefoglalva: Egy Beszrs(s, r) legfeljebb log n tsznezs s legfeljebb 2 Billents mvelettel megvalsthat.
Trls(s, r): Elszr vgrehajtjuk a hagyomnyos trlst, mely egy esetleges csere utn
trli ki az s cscsot, amelynek legfeljebb 1 gyereke van (jellje ezt x; ha nincs gyereke,
jellje x a helyre kerl fiktv levelet). Ha s piros volt, akkor kszen is vagyunk. Ha s
fekete, s a helyre kerl x piros, akkor x-et tsznezve feketre szintn kszen vagyunk.
Az alfejezet elejn tett () megjegyzs miatt, mindig ez az eset ll fent, ha s nem valdi
levl volt.
Teht az az eset maradt, amikor s egy fekete valdi levl. Ekkor egy x fiktv levl
kerl a helyre. Jelljk z-vel a trls utn x szljt, s y-nal a trls utn x testvrt (ez nyilvn ltezik, s nem fiktv levl). Sajnos z-bl az x fel lefele vezet utakon
eggyel kevesebb fekete cscs van, mint az y fel lefele vezet utakon. Ekkor x-et tekintjk
problms cscsnak, neki ktszeresen feketnek kellene lennie, hogy a tulajdonsgok teljesljenek. Ezrt adunk neki egy fekete pontot. Ezt a fekete pontot prbljuk meg felfele
vinni, ha felvittk egy piros cscsba, azt feketre sznezzk s lellhatunk. Ha pedig felr
a gykrbe, s az fekete, akkor elfelejthetjk (ekkor a fa fekete magassga eggyel cskken).
1. eset: y piros. Ekkor z is s y gyerekei is feketk. Bill(y) utn mr x j testvre
fekete, gy folytathatjuk a kvetkez esettel, de most mr x szlje biztosan piros.
z

y
y

z
Bill( y)

A
B

C
A

2. eset: y fekete. A fentiek miatt y nem fiktv levl.


2a. eset: y gyerekei feketk. Ekkor sznezzk y-t pirosra, s a fekete pontot vigyk t
x-rl z-re, s ha z fekete volt, akkor folytassuk felfel az eljrst (klnben z-t feketre
sznezzk s lellunk).
z

z
y

A
B

2b. eset: y-nak az x-szel ellenttes oldalon lev w gyereke piros. Ekkor Bill(y) utn w-t
feketre sznezve (valamint y s z sznt felcserlve) kszen vagyunk.
62

y
y

w
x

Bill(y)

A
B

A
C

Vagy piros, vagy fekete

2c. eset: y-nak az x-szel ellenttes oldalon lev gyereke fekete, a msik, a gyereke piros.
Ekkor egy Bill(a) segtsgvel visszavezetjk az elz esetre.
z

z
y

Bill(a)

D
B

18. llts. Legfeljebb O(log n) vizsglat s felfele lps utn legfeljebb 3 Billentssel megoldhat a mvelet.
Ehhez csak azt kell szrevenni, hogy egyedl a 2a. eset utn kell felfel folytatnunk,
s csak akkor, ha z fekete volt. Az els eset utn (s persze a 2b., 2c. esetek utn) nem
kerlnk ebbe a rszesetbe.

7.5. AVL-fk (Adelszon-Velszkij s Landisz)


Tulajdonsgai:

Binris keresfa,
m(v) a v cscs magassga, m(f ) = 1, ha f fiktv levl,
x : |m(bal(x)) m(jobb(x))| 1.

Ezen tulajdonsg ellenrzse s fenntartsa cscsonknt 2 bittel biztosthat: 1. a bal


gyerek magasabb-e mint a jobb gyerek, illetve 2. a jobb gyerek magasabb-e mint a bal
gyerek.
Indukcival knnyen bizonythat, hogy ha ezek a tulajdonsgok teljeslnek egy d
mlysg fra, akkor ennek legalbb Fd+3 1 cscsa van. Ebbl kvetkezik, hogy a fa
mlysge legfeljebb 1.44 dlog ne lehet.

63

Mveletek :
Beszrs(s, r): Beszrjuk s-et, majd megkeressk a legkzelebbi x st, ahol a 3.
tulajdonsg elromlott; kzben persze a fenti jelzbiteket megfelelen tlltjuk. Majd itt
egy szimpla vagy egy dupla billentssel a tulajdonsg helyrellthat az albbi mdon:
1. eset: s az x bal-bal, vagy jobb-jobb unokjnak a leszrmazottja
y

x
y

x
Bill(y)

C
B

B
s

2a. eset: s az x bal-jobb, vagy jobb-bal unokja


x

s
Bill(s)

Bill(s)
s

2b. eset: s az x bal-jobb, vagy jobb-bal z unokjnak valdi leszrmazottja


x

Bill(z)
z

Bill(z)
D

B
A

C
D

s
s

Nyilvnval, hogy egy beszrsnl az x elem helynek megkeresse legfeljebb d1, 44


log ne idt vesz ignybe s az egsz mvelet vgrehajtsa legfeljebb d1, 44 log ne bit tlltssal, valamint legfeljebb 2 Billentssel jr. rdemes megjegyezni, hogy x megkeresst
mr a Beszrs eltt, mikzben s helyt keressk, knnyen elvgezhetjk. Azonban ekkor
is az s s x kztti cscsoknl kell lltani a biteket. Azonban x felett mr nem, mert a
billentsek utn azok magassga ugyanaz lesz, mint beszrs eltt.
Trls(s, r): Legfeljebb d1, 44 log ne billentssel megoldhat, lehet, hogy az egsz ft
vgig kell billegtetni (itt nem rszletezzk).

7.6. nkiegyenslyoz fk (Splay-tree; Sleator s Tarjan)


Itt is bels trols binris fkat hasznlunk, azonban a kiegyenslyozottsgra nem tesznk explicit felttelt, amit fent kellene tartani. Helyette idnknt billegtetnk, s majd
beltjuk, hogy tlagosan, azaz amortizcis idben minden mvelet elg gyors lesz azaz
O(log n) idej.
j bels mveletek :
Dbill(x): Ktfajta Duplabillentst klnbztetnk meg.
(a) Ha x a nagyszlnek bal-bal, vagy jobb-jobb unokja (s y = p(x)):
Bill(y), majd Bill(x)
64

y
y
z

1. Billents(y)

D
C
A

2. Billents(x)

B
C

(b) Ha x a nagyszlnek bal-jobb, vagy jobb-bal unokja:


Bill(x), majd jra Bill(x)
x

z
y

y
x

1. Billents(x)

D
A
B

2. Billents(x)

Felbillegtet(x):
while p(p(x)) 6= nil
Dbill(x)
if p(x) 6= nil then Bill(x)
A felbillegtets felttelezett hasznossga hasonlt az tfelezsre. Ha x mlysge h volt,
akkor Felbillegtet(x) utn x minden leszrmazottjnak mlysge bh/2c-lel cskken. Ms
cscsok mlysge egy alkalommal akr 2-vel is nhet, de mivel ekkor x leszrmazottjv
vlnak, ezrt ezutn mr minden tovbbi dupla billentsnl cskkenni fog.
Az albbiakban a vesszs mveletek az j mveletek, a vessztlenek a hagyomnyos
binris fban vgrehajtott mveletek.
Keress(x, r):
Keress(x, r)
IF x nem fiktv levl THEN Felbillegtet(x) ELSE Felbillegtet(p(x))
Beszrs(x, r):
Beszrs(x, r)
Felbillegtet(x)

Trls(x, r):
z := p(y), ahol y az x megelzje (lsd az ltalnos trlsi algoritmust)
(y = x, ha x-nek legfeljebb 1 gyereke van)
Trls(x, r)
Felbillegtet(z)
Id: Mindhrom mvelet tnyleges ideje nagyjbl ktszerese a Felbillegtet tnyleges
idejnek. A Lpst elszr gy vlasztjuk meg, hogy annyi elemi lpst tartalmazzon,
65

mint egy dupla billents, s ezzel kielemezzk a Felbillegtet mvelet amortizcis idejt.
Majd vgl megduplzzuk a Lps konstanst, ekkor egy mvelet tnyleges ideje legfeljebb
2+ a Felbillegtetsnl vgrehajtott (dupla vagy szimpla) billegtetsek szma.
Potencil :
x slya: w(x) := x leszrmazottainak szma (sajt magt is belertve)
x rangja: r(x) := blog
P w(x)c
A potencil: P := r(x)
11. Ttel. AI(Felbillegtet(x)) 1 + 3 (r(gykr) r(x)) 1 + 3 blog nc = O(log n).
Bizonyts: Beltjuk minden egyes billent lpsre, hogy teljesl a fenti llts megfelelje. sszeadva ezeket egy teleszkpikus sszeget kapunk, amelybl minden tag kiesik,
kivve 1+3(r(gykr)r(x)). A tovbbiakban r jelli a billents eltti, mg r0 a billents
utni rangot.
1. Szimpla billents: (y = p(x) gykr):
AI 1 + 3 (r(y) r(x)).
y

1. Billents(x)

C
A

r'

P = r0 (x)+r0 (y)r(x)r(y) = r0 (y)r(x) r(y)r(x) 3(r(y)r(x)), mivel


r0 (x) = r(y) s r0 (y) r(y) s r(y) r(x). Teht AI = 1+P 1+3(r(y)r(x)).
2. (a) tpus Duplabillents:
Be kell ltnunk, hogy AI 3 (r(z) r(x)).
P = r0 (z) + r0 (y) + r0 (x) r(z) r(y) r(x) 2 (r(z) r(x)), mivel r0 (z) s
r0 (y) r0 (x) = r(z), s r(y) r(x).
Ha r(z) > r(x) ekkor 3 (r(z) r(x)) 2 (r(z) r(x)) + 1 P + T I.
Ha r(z) = r(x) = r (ez az als-egszrsz miatt lehetsges) r(y) = r s r0 (x) = r.
Elg beltni, hogy r0 (z) < r, mert akkor P 2r + r0 (z) 3r 1, s gy mivel
T I = 1, ezrt AI 3 0.

1. Billents(y)

D
C
A

2. Billents(x)

B
C

66

s jelentse a bal oldalon bejellt adott rszfk cscsainak a szmt. Nyilvn a


jobb oldalon bejellt rszfk cscsszma is , ill. .
Ekkor: w(z) = + .
Indirekt tegyk fel, hogy r0 (z) = r 2r . Mivel r(y) = r 2r , innen:
+ 2r+1 r0 (x) r + 1, ami ellentmonds.
3. (b) tpus Duplabillents:
Minden a 2. ponthoz hasonlan megy.

y
x

1. Billents(x)

D
A
B

2. Billents(x)

Most r0 (y) < r vagy r0 (z) < r -et kell megmutatnunk.


Indirekt tegyk fel, hogy r0 (y) = r0 (z) = r 2r , 2r r0 (x) r + 1, ami
ellentmonds.
Vgs elemzs. Most duplzzuk meg a Lps konstanst.
AI(Keress) P (Keress) + P (Felbillegtet) + 2 + T I(Felbillegtet)
(mivel T I(Keress) belefr a Felbillegtet tnyleges idejbe). gy, mivel P (Keress) = 0,
ezrt AI(Keress) = O(log n).
AI(Trls) P (Trls) + P (Felbillegtet) + 2 + T I(Felbillegtet)
(mivel T I(Trls) belefr a Felbillegtet tnyleges idejbe). gy, mivel P (Trls) < 0,
ezrt AI(Trls) = O(log n).
AI(Beszrs) P (Beszrs) + P (Felbillegtet) + 2 + T I(Felbillegtet)
(mivel T I(Beszrs) belefr a Felbillegtet tnyleges idejbe). gy, ha beltjuk, hogy
P (Beszrs) = O(log n), akkor AI(Keress) = O(log n).
x beszrsakor w(y) csak akkor n, ha x az y leszrmazottja. r(y) csak akkor n, ha y
a gykrbl x-be vezet ton van s w(y) = 2k 1 alak volt. Mivel az ton felfel w(y)
szigoran n csak blog nc ilyen lehet (k = 1 . . . blog nc) P (Beszrs) log n.
sszegezve: Minden mvelet amortizcis ideje O(log n).
Ez az adatstruktra nagyon jl alkalmazhat pldul a Sztvg(S, a) mveletre is: a-t
felbillegtetjk s a kt rszfa lesz a megolds.

67

8. Hash-els
Cl : A sztrmveleteket akarjuk megvalstani gy, hogy tlagosan j megoldst kapjunk. Ehhez elszr is egy olyan h : U [0, 1 . . . M 1] fggvnyt keresnk, amely
az x U elemekre ad egy cmet. A clunk az, hogy ezen a cmen troljuk x-et. M -et
N
.
tblamretnek hvjuk, N pedig az aktulisan trolt adatok szmt jelli; s := M
Az az egyik intuitve nyilvnval cl, hogy a h fggvny egyenletesen tertse szt az
inputokat, vagyis Pr(h(x) = i) M1 legyen minden i < M szmra. Ha itt a valsznsg
az univerzumon egyenletes eloszls szerint rtend, akkor errl persze ltalban knny
gondoskodni. Azonban itt a valsznsget az inputnak rkez kulcsokon kell rteni,
amelyeken egy (ltalban elttnk csak legjobb esetben is krlbell ismert) eloszls van,
amely szerint rkezni fognak. Az elemzsekben fel fogjuk tenni, hogy sikerlt olyan hash
fggvnyt tallni, amelyre a Pr(h(x) = i) = M1 felttel () teljesl. Persze az igazi vletlen
nem j, minden K kulcsra s minden vgrehajtskor h(K)-nak ugyanazt az rtket kell
visszaadnia. Azonban ez a megkvnt vletlenszersg se garantl nmagban tl nagy
sikert, mint azt a jl ismert szletsnap paradoxon mutatja.

Szletsnap paradoxon: Ha N ln 4 M s h egy vletlen fggvny, akkor legalbb


1
valsznsggel lesz olyan x 6= y, hogy h(x) = h(y). Ezt tkzsnek nevezzk.
2
Kt dolgot vizsglunk: hogyan keressnk j hash fggvnyt s hogyan kezeljk az
tkzseket.
Persze mindenekeltt az U univerzum elemeit valahogyan termszetes szmokra clszer lekpeznnk. Ez ltalban knnyen megoldhat gy, hogy klnbz kulcsoknak
klnbz szmok feleljenek meg. Ezt a tovbbiakban felttelezzk, teht innentl gy
tekintjk, mintha U elemei termszetes szmok volnnak 0 s O(|U |) kztt. Persze ez
nem mindig egyszeren megoldhat, pl. lehetnek az univerzum elemei bizonyos, legfeljebb
32 hossz stringek. Megjegyezzk, hogy ilyenkor a gyakorlatban jl hasznlhatak (az
univerzum egsz szmokra lekpezshez, de akr vgleges hash fggvnyknt is) a klnbz ellenrz-sszeg szmol eljrsok (pl. a szabvny CRC 32 bites egszekre kpez, az
Md5sum 128 bitesekre).

8.1. Klasszikus hash fggvnyek


A cl gyorsan szmolhat h fggvny keresse, melyre a () felttel vrhatan nagyjbl
teljesl.
1. Oszt-mdszer:
h(K) = K mod M , ahol K a kulcs (egy szm) s M egy prm.
2. Szorz-mdszer:

n
o
A
K M , ahol {} a trtrsz, M = 2m s W = 2w alak (ltalban w
h(K) =
W
a word RAM gpnk szhossza). Ilyenkor a W -vel val oszts, a trtrsz, az M -el
val szorzs s az egszrsz bitlptetsekkel/levgsokkal gyorsan megvalsthat;
igazbl csak az A K szorzs kiszmtsa ignyel lnyeges idt.
68

A megvlasztsa: az lenne a legjobb vlaszts, ha

A
W

= irracionlis lenne ( < 1).

Megjegyzs: { K} [0; 1).

Szemlltets: egy egysgnyi kerlet krn K-szor mrem fel egyms utn -t.
2

6
5

12. Ttel. (T. Ss Vera): Ha irracionlis, akkor a szomszdos pontok kztti


tvolsgok sszesen 3 flk lesznek s a kvetkez {(K + 1) } az egyik legnagyobb
vet osztja kett.

Ezen bell a legegyenletesebb akkor lesz a feloszts, ha = 51


, ekkor a legnagyobb
2
intervallumot a kvetkez elem az aranymetszs arnyban fogja felosztani.
Ezek alapjn A megvlasztsa: gy vlasszuk A-t, hogy

A
W

51
2

legyen.

3. ltalnos:
Tulajdonkppen brmilyen, gyorsan szmolhat lvletlenszm-genertor megfelel.

8.2. tkzsek feloldsa


8.2.1. Lncolt (vdrs) hash-els
L
0

nil

h(K)=i
nil

M-1
LISTAFEJEK

Kpzeljnk el M db vdrt 0..M 1 cmkkkel, a K kulcsot a h(K) cmkj vdrbe


rakjuk. Egy-egy vdrt lncolt listban trolunk. A lncolt lista adatrszei:
69

egy-egy teljes rekord, vagy


mutat a rekordra s a rekord kulcsa
Keress(K): a h(K)-adik vdrt vgigjrjuk.
Beszrs(K):

Ha tudjuk, hogy nincs a tblban, akkor a h(K)-adik lista elejre szrhatjuk (1


lps).
Ha nem tudjuk, akkor vgigjrjuk a listt, s ha nem talltuk, akkor a vgre beszrjuk.
Trls(K): egyszer (kerss kzben az elz elemet megjegyezzk).

Id:
CN0 : a sikertelen keress vrhat lpsszma, ahol h(K) = i pontosan M1 valsznsggel minden i-re. (Megjegyzs: az (N + 1)-edik elem beszrsa lpsszmnak is ezt
tekinthetjk.)
CN : a sikeres keress vrhat lpsszma, ha minden trolt elemet N1 valsznsggel
keresnk. Ennek becslshez mr fel kell tennnk, hogy a Beszrsoknl igaz volt, hogy
a beszrand kulcsokra Pr(h(K) = i) = M1 teljesl minden i-re. (A ksbbi elemzseknl
a CN0 becslshez is fel kell ezt tenni a rgebben Beszrt kulcsokra is, itt mg nem.)
Emlkeztet: =

N
.
M

Legyenek k0 , k1 , . . . kM 1 a kialakult lncok hosszai, nyilvn ezek tlaga .


P
M
1
X
ki X 1
N
1
0
(ki + 1) =
+
=
+ 1 = 1 + .
Ekkor: CN =
M
M
M
M
i=0
A i valsznsgi vltoz jelentse azt, hogy az i. elem beszrshoz hny lpst tettnk
meg (a keresse is ennyi lps lesz). P
P
P 0
0
s CN = E( N1 i ) = N1
E(i ) = N1
Ci1 a vrhat rtk
Ekkor: E(i ) = Ci1
linearitsa miatt. Innen:



N
N 
N (N 1)
X
1
i1
1 X i1
N 1

2
CN =
1+
=1+
=1+
=1+
1+ .
N
M
N i=1
M
NM
2M
2
i=1
A ksbbiekben szksgnk lesz mg az albbi kvetkezmnyre is:
E

X

ki2 = 2 E


X
ki (ki + 1)
2
=N+

X 
E
ki = 2 E

N
X
j=1

N2 N
< (1 + ) N.
M

70

!
j

N =

A lncolt hash-els elnyei:

egyszer,
mindig tudunk j elemet berakni, azaz nem telik be (amg tudunk helyet foglalni a
memriban),
a nagyon sok elemet tartalmaz vdrbe nem megy nagyobb valsznsggel elem,
mint egy res vdrbe,
knny trlni,
ha pldul 1, akkor CN 1, 5 s CN0 2,
kls tras megoldsknt kifejezetten j. Ekkor a listafej tmb a memriban van,
a pointerek a kls tr lapjaira mutatnak, s egy lapon annyi rekordot trolunk,
amennyi elfr (meg egy pointernek is kell hely!). Pldul ha egy lapra 10 rekord fr
s -t 8-nak vlasztjuk, akkor a lapelrsek vrhat szma sikeres keressnl 1.4,
beszrsnl 1.8 alatt marad.
Ha sokkal tbb keress van, mint egyb mvelet, akkor clszer lehet a lncolt
listkat valamilyen rtelemben rendezve trolni.

Ha kulcs szerint nvekven rendezve troljuk, az a sikertelen keresseket gyorstja meg, ha a lncban nagyobb kulcsot talltunk, mint a keresett, akkor
megllhatunk.
Ha tudjuk a keressi valsznsgeket, s ezek szerint cskken sorrendben
troljuk a rekordokat, akkor a sikeres keressek vrhat ideje lesz kisebb.
Ha ezeket nem tudjuk, de feltesszk, hogy egy idben lland eloszls ltal
determinltak, akkor rdemes mindig a megtallt rekordot a lista elejre rakni.
Ha az ismeretlen eloszls idben is vltozik, akkor a legjobb recept az, hogy a
megtallt rekordot cserljk fel a megelzvel (lsd a [4] knyvben).

Htrnya:

nagy memriaigny: M + N darab pointer kell (kls trolsnl kevesebb),


minden beszrsnl j memriarekeszt kell alloklni, s fleg egy lista elemei sszevissza lesznek a memriban, ezrt a listn vgigmens a gyakorlatban elg lass
(nem tudjuk jl kihasznlni a gyorsttrat).

8.3. Nylt cmzs


A nylt cmzses mdszerekben kzs, hogy mindig egy fix tblt hasznlunk (tmbt) s
feltesszk, hogy N M 1 (mindig hagyunk egy res helyet, hogy a sikertelen keressnl
ne kelljen kt felttelt vizsglni).
0

M-1

71

A hash fggvny: h : U [0, M 1] mellett tbb msik hash fggvnyt is hasznlunk:


hi : U [1, M 1], ahol i = 1, . . . M 1 s h0 0.
A kvetkez gynevezett keressi sorozatot vizsgljuk:
h(K)h0 (K), h(K)h1 (K), . . . h(K)hM 1 (K) mod M , ahol a h1 (K), h2 (K), . . . hM 1 (K)
sorozat ktelezen az 1, 2, . . . M 1 egy permutcija minden K-ra.
Keress: kiszmtjuk a sorozatban adott cmeket addig, amg vagy megtalljuk a
keresett elemet, vagy pedig tallunk egy res helyet az adott tblban (ekkor nincs benne).
Beszrs: ahol a sikertelen keress lellt: a sorozat els res helyre.
Megjegyzsek.
A nylt cmzs nv onnan szrmazik, hogy nincs elre eldntve, hogy hov rakjuk az egyes
elemeket.
Annl jobb lesz az eredmny, minl "vletlenebb" a permutci minden egyes K kulcsra.

8.4. Lineris hash-els


A msodik hash fggvny: hi i. Ha a tmbben felfel lpkedve elrnk a legfels elemig,
akkor alulrl indulunk tovbb. (Ezrt szerepel a hash fggvnyben kivons sszeads
helyett, a 0-val gyorsabban tudunk sszehasonltani.)

h(K)

Elny:

Gyors s egyszer.
Lpsszmok : CN = 21 1 +
CN s CN0 nhny rtke:

1
1

CN
CN0

s CN0 =
1
2

2
3

1.5
2.5

2
5

1
2


1 2
1 + ( 1
) .

0.8
3
13

0.9
5.5
50.5

Htrnyok :

Ha kialakul egy hossz teltett rsz (lnc), akkor nagy annak a valsznsge, hogy
a kvetkez elem is ebbe a lncba rkezik.
A lncok ssze tudnak nni (teht nagyon rzkeny a j h vlasztsra, az ismeretlen
input eloszls korrelcii is fontosak).

72

Ha nincs elre j becslsnk N maximlis rtkre s emiatt betelik a tbla, akkor


nincs jobb megolds, mint felvenni egy j, praktikusan ktszer akkora tblt (s
persze egy j h fggvnyt), s oda jra egyesvel behash-elni az eddigi elemeket. Ez
minden nylt cmzses mdszerre igaz.

Ez azonban nem olyan nagy baj, ha amortizlt idben szmolunk. St, rdemes mr
pl. N M/2 esetn j, ktszer akkora tblt nyitni.
Gondoljuk meg az albbiakat (erre a gondolatmenetre mg szksgnk lesz ksbb
is). Ha a vgs tbla mrete M , akkor N M/4. Az sszes tblnk egyttesen
2 + 4 + . . . + M < 2M 8N helyet foglal el. A beszrsok sszes szma (belertve az
j tblkba val beszrsokat is) legfeljebb N plusz a kisebb tblamretek sszegnek
(2 + 4 + . . . M/2 < M ) fele, ez pedig legfeljebb M/2 + N 3N . Teht egy elemet
tlagosan maximum hromszor szrunk be (egy maximum 50%-os teltettsg tblba).
Egy j tblba val tpakolskor persze a rgi tbln vgig kell menni, hogy sszeszedjk
az addig beszrt elemeket, de ez is csak 2 + 4 + . . . + M/2 < M 4N lps.
Ennl a mdszernl mg elg egyszeren lehet trlni.
Trls: Az okoz gondot, ha a ksbbiekben egy olyan K 0 -t keresnk, hogy K 0 a trlt
elem felett (ciklikusan rtend!), h(K 0 ) pedig alatta van.

K'
K1
trlt
h(K')

Megolds: Elindulunk a trlt elemtl felfel. Ha gondot okoz K 0 elemet tallunk, azt
nyugodtan trakhatjuk a trlt elem helyre, s K 0 eredeti helyt tekintve trlt helynek,
rekurzvan folytatjuk az eljrst. Ha viszont elrnk egy res helyet, akkor nyugodtan
megllhatunk, mindent rendbe raktunk.

8.5. Dupla hash-els


Itt a h mell csak egy darab h0 hash fggvnyt keresnk, melyre h0 (K) [1, M 1] s
minden K-ra relatv prm M -hez. Legyen hi (K) = i h0 (K).
Ez a mdszer akkor lesz igazn j (amit a tovbbi elemzsekben fel is tesznk), ha
Pr h(K1 ) = h(K2 ) s h0 (K1 ) = h0 (K2 ) M (M1 1) teljesl minden K1 6= K2 -re.
K
Oszt-mdszer : M 0 , M legyenek ikerprmek s h0 (K) := 1 + (b M
c mod M 0 ).
K
Megjegyzs: a K mod M kiszmolsakor a b M
c rtket is kiszmoltuk. A +1 pedig azrt kell,
hogy i h0 biztosan ne legyen 0.

Szorz-mdszer : Jellje a az AK szorzat kvetkez m bitjt. h0 (K) := a or 1 (az


utols bitjt 1-re lltjuk, gy nem lesz 0 s biztosan relatv prm lesz a kett-hatvny
M -hez).
73

A*K


1
Lpsszmok : CN = 1 ln 1
s CN0 =
CN s CN0 nhny rtke:

CN
CN0

1
2

h(K)

1
.
1

2
3

0.8 0.9
1.39 1.65 2.01 2.56
2
3
5
10

Megjegyzs: Ez egy elg j mdszer (ha h s h0 teljestik a feltteleket), ennl sokkal jobbat nem
is igen vrhatunk a nylt cmzseken bell.

Trls dupla hash-elsnl : Az elz trkkt itt nem alkalmazhatjuk. Amikor trlnk
egy elemet, akkor egy specilis szimblumot helyeznk el a helyre, ami azt jelli, hogy az
adott elem trlt. A beszrsnl ide beszrhatunk, de a keressnl tovbb kell lpnnk.
Az a problma, hogy sok trlsnl gyorsan megtelik a tbla ilyen szimblumokkal.

8.6. A dupla hash-els Brent-fle vltozata


Ennl a mdszernl CN 2.49, ha 1. A beszrsnl nmi plusz munkt vgznk,
hogy a majdani keresseket gyorstsuk. J pld. program fordtsa sorn szimblumtbla
ptsre.
Megolds: Ha a beszrand K kulcsot be tudom rakni az els vagy a msodik helyre,
akkor berakom. Klnben sima beraksnl az keresse mr legalbb hrom lps lenne.
Legyen a h(K) helyet elfoglal kulcs K1 . Ha K1 -et eggyel htrbb tudom rakni a keressi
sorban, akkor K1 keressn 1-et rontok, de legalbb 2-t javtok K keressn.
Az algoritmus ez utn is moh mdon folytatdik. Ha K1 -et nem sikerlt a h(K)
0
h (K1 ) helyre rakni, akkor utna K-t prbljuk a h(K) 2h0 (K) helyre rakni, ha ez se
megy, akkor K1 -et a h(K)2h0 (K1 ) helyre s K-t a h(K) helyre, ha ez se megy, akkor K2 -t
(aki a h(K)h0 (K) helyet foglalja) prbljuk eggyel htrbb rakni a h(K)h0 (K)h0 (K2 )
helyre s K-t berakjuk a h(K) h0 (K) helyre, s gy tovbb.

8.7. Univerzlis hash-els


tlet: A hash fggvnyt vlasszuk vletlenl egy elegenden nagy halmazbl.
H : U [0, M 1] : legyen hash fggvnyek egy halmaza. 
H univerzlis, ha K1 6= K2 U -ra : PrhH h(K1 ) = h(K2 ) M1 .
Konstrukci:
Feltesszk, hogy M prm, s K-t felrjuk M alap szmrendszerben:
P
K = ri=0 xi M i , ahol 0 xi < M s r-et gy vlasztjuk, hogy K < M r+1 minden
kulcsra.
Legyenek a0 , aP
1 , . . . ar [0, M 1] vletlenek s fggetlenek.
ha0 ,...ar (K) := ri=0 ai xi mod M . H := {ha0 ,...ar }0a0 ,...ar <M .
74

13. Ttel. Ez univerzlis, vagyis Pr


legalbb egy j-re xj 6= yj .

ai xi mod M =

ai yi mod M

1
,
M

ha

Bizonyts: ha K1 6= K2 (s xi reprezentlja K1 -et, yi pedig K2 -t), akkor valban j,


hogy xj 6= yj .
Elg beltnunk, hogy a fenti egyezs feltteles valsznsge 1/M minden rgztett
a0 , a1 , . . . aj1 , aj+1 , . . . ar rtkre.
P
Ha egyezs van, akkor: aj (xj yj ) ri=0,i6=j ai (xi yi ) mod M . Mivel xj yj 6 0
s a jobb oldal a feltteles valsznsgben (rgztett ai -k esetn, i 6= j) egy rgztett
szm, gy egyetlen aj ltezik, ami kielgti a kongruencit.
Megjegyzs: Vannak ennl kifinomultabb megoldsok is. s nha szksg is van arra, hogy olyan
fggvnyt tudjunk sorsolni, ami nem csak egyenletes, hanem (tbbszrs) fggetlensget is biztost.

8.8. Egyenletes hash-els


Az egyenletes hash-els egy idealizlt elmleti modell, nem tartoznak hozz algoritmusok. Azt tesszk fel, hogy brmely pillanatban brmely rgztett N helye a tblnak
egyforma, azaz 1/ M
valsznsggel foglalt. Cserbe viszont itt a lpsszm-elemzsek
N
egyszerek, s lthatjuk, hogy hogyan s mirt jnnek ki a dupla hash-elsnl megismert
lpsszmok. Ugyangy elemezhet a kiss jobban kzzel foghat uniform nylt cmzs is,
amikoris azt tesszk fel, hogy minden kulcsra a h(K) h0 (K), h(K) h1 (K), . . . h(K)
hM 1 (K) mod M keressi sorozat 1/M ! valsznsggel veszi fel brmely permutci rtkt. Ekkor ugyanis egy elem beszrsakor mindegy, hogy ppen melyik N sora foglalt
a tblzatnak, mivel egy vletlen permutci ltal adott keressi sorozat mentn prblgatjuk beszrni, ez ugyanaz, mintha egy fix sorrend mentn akarnnk beszrni, viszont
brmely N sor egyforma valsznsggel foglalt.
Pk :=
Pr(
+ 1)-edik
 M
 Az (NM k
 M  elem beszrshoz pontosan k kereslps szksges) =
M k
/ N = M N 1 / N . Ugyanis legyen az N + 1. elem keressi cmsorozata
N k+1
h1 , . . . , hk , . . . . Ha a beszrshoz k kereslps kell, az pontosan azt jelenti, hogy a tblban h1 , . . . , hk1 cmek foglaltak, mg
 aMhk cm szabad. Az elejn tett feltevs szerint
M k
ennek valsznsge pedig pont N k+1 / N . Felhasznlva, hogy a valsznsgek sszege
P
1, azaz hogy M
k=1 Pk = 1, kapjuk:

75

CN0

M
X

k Pk = M + 1

k=1
M
X

M
X

(M + 1 k) Pk =

k=1

  
M k
M
M +1
(M + 1 k)
=
M N 1
N
k=1

  
M
X
M +1k
M
M +1
(M N )
=
M

N
N
k=1

  
M +1
M
M + 1 (M N )
=
M N +1
N

  
M +1
M
M + 1 (M N )
=
N
N
M +1
M +1
=
=
M + 1 (M N )
M N +1
M N +1
N
1
1+

= 1 + + 2 + 3 + . . .
M N +1
1
Ez alapjn a sikeres keress vrhat lpsszma is meghatrozhat a lncolt hashelsnl ltott alapelv alapjn:


N 1
M +1
1
1
1
1
1 X 0
C =

+
+
+ +
=
CN =
N k=0 k
N
M +1 M
M 1
M N +2
M +1
1
1
(HM +1 HM N +1 ) ln
,
N

1
ahol Hn a termszetes szmok reciproksszege n-ig, amirl ismert, hogy Hn ln n + ,
ahol az Euler-lland.

8.9. Tkletes hash-els


A Fredman, Komls s Szemerdi ltal kitallt techniknak rszletesen csak a statikus
vltozatt vizsgljuk, a dinamikusrl csak rviden tesznk emltst. Cl: adott egy N
elem ismert, fix sztr. ptsnk fel O(N ) vrhat idben egy O(N ) trhelyet foglal
struktrt, hogy utna minden (sikeres ill. sikertelen) keress ideje biztosan O(1) legyen.
Ezt a ltszlag lehetetlen feladatot rszint a hash-elsnl eddig is hasznlt feltevsek (h
kiszmtst konstansnak tekintettk, s feltettk, hogy egy kulcs elfr egy memriarekeszben) miatt lehet megvalstani, msrszt a felpt algoritmusunk randomizlt lesz,
teht csak a vrhat futsi ideje lesz lineris.
Elszr is rgztnk egy M N prmet, vlasztunk egy h univerzlis hash-fggvnyt,
s egy segdterletre lncolt hash-elssel behash-eljk
P 2 a sztr elemeit. Ezutn kiszmtjuk a lncok ki hosszait, s ellenrizzk, hogy
ki 4N igaz-e. Ha nem, akkor j h
fggvnyt sorsolunk, jra hash-elnk, ellenrznk, s..t. Ha teljesl, akkor folytatjuk a
msodik rsszel.
76

Mieltt a msodik rszt rszleteznnk,


elbb nzzk meg az els rsz vrhat futsi ideP 2
jt. Mintmr bizonytottuk,
E
(
k
)
<
2N
, mivel 1. Ezrt a Markov-egyenltlensg
i

P 2
miatt Pr
ki > 4N < 1/2. Teht maximum 1/2 valsznsggel kell msodik h fggvnyt sorsolni, maximum 1/4 valsznsggel kell harmadikat, s..t., teht az egybknt
lineris idben vgrehajthat hash-elst (egy sztr elemeit szrjuk sorba be, teht lehet
az j elemet ellenrzs nlkl a lncok elejre rakni) vrhatan kevesebb, mint kettszr
hajtjuk vgre.
Megjegyzs:
Igazbl az sem baj, ha az inputban
tbbszr is szerepelhetnek. A

P egyes sztrelemek
P 2
ki (ki + 1) > 25 N , teht azt is megtehetjk, hogy
ki > 4N felttel ekvivalens azzal, hogy 21
mindig ellenrzssel (s gy a vgre) szrunk be, s szmoljuk, hogy az egyes elemek hnyadikak
lettek a lncukban. Ha ez az sszestett szm meghaladja az 52 N -et, akkor az egszet eldobjuk, j
h-t sorsolunk, s ellrl kezdjk.

A vgs struktra gy fog kinzni, hogy egy 0-tl (M 1)-ig indexelt T tmbben
nem lncfejek lesznek, hanem az i. sorban nhny szm, s egy link egy Ti hash-tblra,
melynek mrete Mi ki2 . A Ti tbla fogja tartalmazni a lncolt hash-elsnl az i. lncba
P i (i) (i)
aj xj mod Mi hashkerlt elemeket. Ezekbe a tblkba jabb univerzlis hi = rj=0
(i)

fggvnyekkel hash-eljk be ezeket az elemeket, ahol xj a K kulcs szmjegyei Mi alap


szmrendszerben. Arrl fogunk gondoskodni, hogy egyltaln ne legyen tkzs. Teht
minden i-re a kisorsolt hi fggvnnyel behash-elnk a tblba, s ha egyszer is tkzs
van, akkor a tblt kirtjk s j hi fggvnyt sorsolunk. Annak a valsznsge,
hogy

ki
van olyan kt klnbz kulcs, melyek tkznek, legfeljebb 1/2, mivel 2 pr van, s egy
pr 1/Mi 1/ki2 valsznsggel tkzik. Teht az ismtlsek vrhat szma itt is kett
alatt van.
(i)
A T tmb i. sorban troljuk ki s Mi rtkt, az aj rtkeket (ezek sszhossza
ugyanannyi, mint egy kulcs), s a pointert a Ti tblra. Persze ki 1 esetn nem
rdemes kln tblt trolni. Knny ltni, hogy ez sszesen O(N ) tr. (Megjegyzs: az
univerzlis hash-els trgyalt mdjnl feltettk, hogy az Mi szmok prmek. De ismert,
hogy minden szmhoz van nem sokkal nagyobb prm. Msrszt lteznek msfajta, nem
prm Mi -kre is mkd univerzlis hash-elsek is, ott Mi = ki2 is vlaszthat (lsd az [1]
knyvben)).
Vilgos, hogy ezutn a Keress(K) gy megy: kiszmtjuk i = h(K) rtkt. Kiolvassuk T (i)-t, kiszmtjuk hi (K)-t, s megnzzk, hogy a Ti tbla ennyiedik sorban K
van-e. Ha igen, megtalltuk, ha nem, akkor K nincs a sztrban. Ez persze O(1) lps.
8.9.1. Dinamikus tkletes hash-els
Meglep mdon ez a mdszer kiterjeszthet dinamikus sztrakra, mg trlsekkel egytt
is. Itt a clzott s elrt lpsszmok a kvetkezk: a Keress tovbbra is legrosszabb
esetben O(1) lps. A Beszrs s Trls amortizcis idejnek a vrhat rtke pedig
szintn konstans. s folyamatosan csak O(N ) trat akarunk hasznlni (N az aktulisan
a sztrban lev szavak szma).
A dinamikus vltozat alapelvei: Fent kvnjuk tartani, hogy N M 2N , ahol M
a T tmb mrete. Beszrs(K) esetn, ha N > M lenne, akkor elszr is j struktrt
77

ksztnk: M -et megktszerezzk, s az eddigi sztr elemeit a statikus esetnl ltott


mdon trakjuk az j struktrba. Ha K helye res, berakjuk. A T tblban ki mellett
az aktulis Ti tbla Mi mrett is troljuk, de ilyenkor csak ki -t frisstjk. Ha K-t
nem tudjuk berakni a Ti tblba, mert tkzne, akkor kt eset van. Ha az aktulis Mi
legalbb ngyzete az aktulis ki -nek, akkor j hi fggvnyt sorsolunk. Ha nem, akkor
Mi rtkt megduplzzuk
(illetve vlasztunk a ktszeresnl picit nagyobb prmet), s
P
ellenrizzk, hogy a Mi rtk meghaladta-e 4M -et. Ha igen, akkor a fentiek szerint M et megktszerezzk, s az eddigi sztr elemeit a statikus esetnl ltott mdon trakjuk
egy j struktrba. Ha nem, akkor a rgi Ti elemeit j hi vlasztsval trakjuk az j,
ktszer akkora Ti tblba. A Trls(K) simn megy, de ha N < M/2 lett, akkor M -et
megfelezzk, s az eddigi sztr elemeit a statikus esetnl ltott mdon trakjuk egy j
struktrba.

9. A van Emde Boas struktra


A Prim algoritmushoz szeretnnk jobb kupacot kszteni abban az esetben, ha a kulcsok
(az lek kltsgei) nem tl nagy termszetes szmok. Elszr is vegyk szre, hogy ha
van egy sztrunk trlssel, mely mg tudja a Min(S) mveletet is (ez visszaadja a sztr
legkisebb elemt), akkor tudunk belle kupacot is csinlni gy, hogy a sztrelemek mellett
rtkknt egy lncolt listban troljuk azon cscsok neveit, melyek kulcsa pont az adott
sztrelem. Itt pl. a Kulcs-cskkents gy nz ki: az adott elemet kitrljk a lncolt
listbl, ha az kirlt, hvunk egy sztrra vonatkoz Trlst. Ezutn lecskkentjk a
kulcst. Ha az j kulcs benne van a sztrban, akkor befzzk annak listjba, egybknt
elbb kell egy sztrbeli Beszrs mvelet. Ez ltalban nem tl hatkony, de most itt
az lesz.
Teht elegend egy sztrat megvalstani, melyben a Beszrs s Trls mveleteken
kvl a Kv(x) mveletet valstjuk meg, ahol Kv(x) visszaadja a sztr legkisebb olyan
elemt, mely x. Ez nyilvn ltalnostja a Keress s a Min mveleteket. Az ilyen
sztrak nmagukban is fontosak, nemcsak kupacot lehet a segtsgkkel csinlni, hanem
sok ms feladathoz is hasznljk ket. Az univerzumunk a [0 . . . C 1] intervallum egsz
szmaibl ll. Az a clunk, hogy minden mvelet O(log log C) idben fusson. Legyen
k
k = dlog log Ce, ekkor knyelmi okokbl feltehetjk, hogy C = 22 . Elszr egy rekurzv
defincit adunk meg, amely sajnos nem teljesti az idkorltot. Utna ezt kijavtjuk,
majd rtrnk az implementls nhny fontos krdsre.
l
Egy l tpus vEB struktra 22 sztrelem trolsra alkalmas. Hrom szmbl s
l1
22 + 1 pointerbl ll. A szmok: meret, az aktulisan trolt szavak szma, min, a
legkisebb trolt sztrelem, s max, a legnagyobb trolt sztrelem. A felso nev pointer
l1
egy darab l1 tpus vEB struktrra mutat, mg az also(a) pointerek (0 a < 22 ) egyegy l 1 tpus vEB struktrra mutatnak. Ugyan nem fontos kln Keress mveletet
csinlnunk, mgis az mutatja legjobban, hogy hogyan fog mkdni az egsz. Tegyk fel,
k
hogy a k tpus vEB struktrban
akarjuk keresni az i < 22 (teht 2k bites) szmot.

k1
Elszr is felrjuk i-t a C + b alakban, ahol a, b < 22 . Ez valjban egy egyszer
mvelet: a lesz i els 2k1 bitje, mg b a msodik 2k1 bitje. Ezutn egyszeren az also(a)
pointer ltal mutatott k 1 tpus vEB struktrban keressk rekurzvan a b szmot. A
78

felso struktra a Kv mvelethez kell: azon a szavakat tartalmazza, melyekre also(a) nem
res.
Analgia: kpzeljnk el egy 2k mlysg teljes binris ft, melyben a bal gyereknek
a 0 bett, a jobb gyereknek az 1 bett feleltetjk meg. Ekkor a levelek felelnek meg az
univerzum elemeinek. A tbbi cscsba a leszrmazott levelek kzl a sztrelemek (nem
res levelek) szmt, minimumt s maximumt rjuk. A Keress s Kv mveleteknl, a
paramterknt kapott szhoz (levlhez) vezet ton binris keresst vgznk, ez k lps.
Ez mg magban nem j, egy elem Beszrsakor pl. az t minden cscsn (2k db) kellhet
adatot frissteni. A rekurzv definci s az els megvalsts utni trkk pont ezt hivatott
kijavtani. Vglis egy bels cscsban ktfle hozztartoz rszfa (felso s also) adatait is
trolnunk kell. s mindkett fajtbl tbb, klnbz mlysgre is szksgnk lesz.
A fentiek alapjn az els rekurzv megvalstsunk a kvetkez. Legyen T egy troland vEB struktrra mutat pointer. A struktra tpust a msodik paramterben adjuk
meg. Egy p pointer ltal mutatott struktra max vltozjt p.max-szal fogjuk jellni, s
persze hasonlan a min s meret vltozkat is.
Kv(T, l, i):
l1
G := 22 ; i = a G + b
if also(a).max b then return(a G+Kv(also(a), l 1, b))
else c :=Kv(felso, l 1, a + 1)
return(c G+also(c).min)
Ha a Kv eljrst meghvjuk egy k tpus struktrra, O(1) lpst tesznk, plusz egy
darab rekurzv hvs egy k 1 tpus struktrban. Ez nyilvn a kvnt O(k) lpst adja
sszesen.
Beszrs(T, l, i):
l1
G := 22 ; i = a G + b
if also(a).meret= 0 then Beszrs(felso, l 1, a)
Beszrs(also(a), l 1, b)
T.meret, T.max, T.min frisstse
Trls(T, l, i):
l1
G := 22 ; i = a G + b
Trls(also(a), l 1, b)
if also(a).meret = 0 then Trls(felso, l 1, a)
T.meret, T.max, T.min frisstse
A Beszrsnl az utols sor vgrehajtsa nyilvnval, a Trlsnl a rsz-struktrk
trls utni rtkeibl minden knnyen szmolhat, pl. T.min=also(felso.min).min. Sajnos ezen kt utbbi mveletnl a konstans lps mellett KT darab rekurzv hvs is lehet
legrosszabb esetben, ez pedig csak O(2k ) lpsszmot garantl.
A kijavtshoz elszr is szrevesszk, hogy amikor kt rekurzv hvs van, akkor az
egyik vagy egy res struktrba beszrs, vagy egy 1-elembl val trls. Ezeket kellene
rekurzv hvs helyett konstans idben megvalstani. A kvetkez, meglepen egyszer
79

trkk segt: a min vltozban trolt szt nem troljuk a rsz-struktrkban! Ez persze
egy picit elbonyoltja a fenti kdokat, de mivel garantltan csak egy rekurzv hvs lesz
mindig, ezrt kiadja az O(k) lpsszmot.
Kv(T, l, i):
l1
G := 22 ; i = a G + b
if i min then return(min)
if also(a).max b then return(a G+Kv(also(a), l 1, b))
else c :=Kv(felso, l 1, a + 1)
return(c G+also(c).min)
Beszrs(T, l, i):
if meret= 0 then meret:= 1; max:=min:= i; return
if min> i then csere(min, i)
l1
G := 22 ; i = a G + b
if also(a).meret= 0 then Beszrs(felso, l 1, a)
Beszrs(also(a), l 1, b)
T.meret, T.max frisstse
Trls(T, l, i):
if meret= 1 then meret:= 0; return
l1
G := 22
if min= i then i :=min:=felso.minG+also(felso.min).min
i=aG+b
Trls(also(a), l 1, b)
if also(a).meret = 0 then Trls(felso, l 1, a)
T.meret, T.max frisstse
Ltszlag itt is megmaradt a kt rekurzv hvs, azonban az egyik nem eredmnyez
tovbbi rekurzv hvsokat s konstans idben vgrehajtdik.
Megjegyzs: a 0 tpus struktra maximum kt elemet trol. Erre elg a max s min, gy ezekhez
nem tartoznak pointerek (rszstruktrk). Persze a kdba is bele kellene rni ezt a kivtelt...

9.1. Trhely, megvalsts, javts


Mennyi trat hasznlunk? Egyltaln sszesen hny darab vEB struktrt kell trolnunk? s hny pointert? s ezeket hogyan? Ami elg vilgos: egy struktra rszstruktrinak mrett rdemes magban a struktrban a pointer mellett/helyett trolni, azaz
a 0 mretekre pointer nem is kell. Az inicializls sem egyszer, ha minden lehetsges
rsz-struktrt az elejn inicializlni akarnnk, az mr magban nagyon sok idt venne
el. Egy rsz-struktrt igazbl elg lenne akkor inicializlni, ha mrete 0 fl ntt. Ekkor viszont az a baj, hogy az res struktrba val beszrs nem konstans idej. Teht
jobb a rszstruktrk minimumt is a szlben trolni, s csak akkor inicializlni, ha a
80

mret 2-re n, de mg ezzel is tbb baj van. Egyrszt ilyenkor mennyi a futsi id? Mit
csinlunk trlskor, ha egy rszstruktra mrete 1-re cskken? Ha trljk, akkor lehet,
hogy ugyanazt sokszor kell jra inicializlni, ha meg nem, akkor a trhelynk lehet tl
nagy az aktulisan trolt elemek n szmhoz kpest.
Egy c < 2t termszetes szmhoz rendeljk hozz a ct {0, 1}t szt, mely a c binris
alakja az elejn elegend szm 0-val. Egy-egy troland vEB struktrhoz hozzrendelnk egy (ct , l) nevet. (ct , l) egy l-tpus vEB struktra neve, ha
0 l k, s
0 t s t + 2l 2k . (t egy k bites szm, a vgn legalbb l db. 0-val).
A (ct , 0) nev struktrknak nincsenek rszstruktri.
Ha l > 1, akkor a (ct , l) nev struktra felso pointere a (ct , l 1) nev struktrra
mutat,
l1
v) s ha a < 22 , akkor az also(a) pointere a (ct a2l1 , l 1) nev struktrra mutat.
(Itt nem szorzs van, hanem konkatenci!)
vi) A fstruktra neve (, k), ahol most az res sz.

i)
ii)
ii)
iv)

Egy (ct , l) nev vEB struktra indexe legyen a kvetkez kettes szmrendszerbeli
k
szm: 1ct 01 . . . 1, ahol a vgn l darab egyes van. Mivel t+l 2k , ezrt maximum 22 +2 =
4C darab struktrra van szksgnk. Ha ezeket egy tmbben troljuk (az i index
struktra meret, min, s max rtkeit az i-edik sorban), akkor a struktra pointereit mr
nem kell trolni, nevk s cmk a fentiek alapjn szmolhat. gy a tmb mrete 4C, az
sszes trigny 12C.
Nem beszltnk mg az inicializlsrl: sajnos legalbb a fenti tmbben lev meret
rtkeket 0-ra kell lltani. Ez a gyakorlatban egy utastsnak ltszik (calloc), s tnyleg
gyors is, de elmleti szempontbl kicsit ront a vEB struktrk szpsgn.
Azonban a 12C trhely nem mindig elfogadhat. A log log C futsi id mg nagyon j
pl. C = n5 esetn is, de n adatot nem szeretnk n5 helyen trolni. Erre az ad megoldst
(s az inicializlsi problmt is kikszbli), ha a fenti tmb helyett dinamikus tkletes
hash-elst hasznlunk. Ennek univerzuma a cmtartomny (a szmok 0-tl 4C-ig), s
minden nemres struktra cme szerepel, mint kulcs, mellette rtkknt a meret,max,min
hrmas. Kezdhetnk egy, csak a f struktrt tartalmaz egyelem hash-tblval, s
csak ha a keresett rszstruktra indexe nem szerepel a hash tblban, akkor szrjuk oda
be a dinamikus hash-els Beszrs mveletvel. Mivel a dinamikus hash-els mveletei
vrhatan tlagosan konstans idejek, ez nem rontja el a vEB mveletek lpsszmt, a
trat viszont leviszi O(n)-re.
A Beszrs mveletet elemezve lthat, hogy n elem Beszrsa utn legfeljebb (k +
1) n olyan index lesz, amely nem res struktrra mutat, teht a dinamikus hash-els
sorn ezt az indexet be kell szrni, ezrt a hash-elsnl a beszrsok szma s a trigny
O(n log log C).

10. Az LCA feladat


Nagyon sokszor trolunk adatokat gykeres fkban. Ezeken az egyik leggyakrabban hasznlt (sokszor bels) alapmvelet az LCA (Least Common Ancestor = Legkzelebbi Kzs
81

s) feladat: ha u s v a fa cscsai, akkor LCA(u, v) visszaadja u s v legkzelebbi (a


gykrtl legtvolabbi) kzs snek a nevt.
Termszetesen szinte brmilyen trolsi md esetn meg tudunk vlaszolni egy ilyen
krdst O(d(u, v)) lpsben, ahol d(u, v) a cscsok tvolsga a fban. A clunk ezzel
szemben az, hogy O(n) elfeldolgozs utn (ahol n a fa cscsainak a szma), O(n) trban
gy troljuk el a ft, hogy utna minden LCA(u, v) krdst meg tudjunk vlaszolni O(1),
azaz konstans lpsben!
Egy ltszlag teljesen fggetlen feladat az RMQ (Range Minimum Query = Rszintervallum Minimum Lekrdezs). Troland egy n mret A tmb, a krds kt szmbl
ll: 1 i j n. Az RM Q(i, j) krdsre a vlasz egy k index, melyre i k j, s az
ilyenek kzl az, amelyre A(k) minimlis (ha tbb ilyen van, akkor brmelyik).
14. Ttel. Ha az RMQ feladatra van (O(n), O(1)) megoldsunk (azaz olyan, mely O(n)
idben s trban elfeldolgozva a tmbt, utna minden krdsre konstans idben vlaszt
ad), akkor az LCA feladatra is kaphatunk (O(n), O(1)) megoldst.
15. Ttel. Ha az LCA feladatra van (O(n), O(1)) megoldsunk, akkor az RMQ feladatra
is kaphatunk (O(n), O(1)) megoldst.
Ez gy mg fbl vaskarika, azaz teljesen haszontalannak ltszik. Mgis van egy
kitrsi pont. Definiljuk a 1-RMQ feladatot, mint az RMQ feladat azon megszortst,
amikoris az A tmb minden eleme pontosan eggyel tr el az elztl: 2 i n :
|A(i) A(i 1)| = 1.
A fenti 14. ttel bizonytsa automatikusan adja majd a kvetkez, ersebb ttelt.
16. Ttel. Ha a 1-RMQ feladatra van (O(n), O(1)) megoldsunk, akkor az LCA feladatra is kaphatunk (O(n), O(1)) megoldst.
Elszr ezt bizonytjuk, majd megadjuk a kvnt megoldst a 1-RMQ feladatra.
Vgl bizonytjuk a 15. ttelt, azaz az ltalnos RMQ feladatot visszavezetjk a (binris)
LCA feladatra.
Bizonyts: (16. ttel): Egy fa Euler-stjnak nevezzk azt a krstt, amely a fa
minden ln mindkt irnyban pontosan egyszer halad t. A sta ltal rintett cscsok
neveit egy E nev 2n1 mret tmbbe rendezzk, az els s utols elem legyen a gykr.
Ebben minden cscs a fokszma-szor szerepel (kivve a gykr, az eggyel tbbszr). Ez a
tmb mlysgi keresssel knnyen elllthat, ugyangy, mint az albbi kt tmb is: L(i)
jellje a sta sorn i-ediknek rintett cscs mlysgt, R(u) pedig az u nev cscs els
elfordulsnak indext az E tmbben. Nzznk egy LCA(u, v) krdst, feltehetjk, hogy
R(u) R(v) (klnben u-t s v-t kicserljk). Knny meggondolni, hogy LCA(u, v) =
E(RM QL (R(u), R(v))), azaz a legkzelebbi kzs s a sta mentn u s v kztt rintett
cscsok kzl a legkisebb mlysg. Knny ltni hogy az L tmb teljesti 1-RMQ
feladat inputjra tett megszortst.

10.1. A 1-RMQ feladat


Elszr nzzk meg, milyen naiv megolds adhat az ltalnos RMQ feladatra. Knnyen
kaphatunk egy (O(n2 ), O(1)) megoldst, ha minden i j prra kiszmoljuk s eltroljuk
a vlaszt. Ezt O(n2 ) idben tnyleg ki tudjuk szmtani dinamikus programozssal.
82

Ennl sokkal rafinltabb megolds (mg mindig az ltalnos RMQ feladatra) az albbi:
Nem kell minden i j prra kiszmtani a megoldst, elg az olyan i j prokra,
ahol j i + 1 kettnek egy hatvnya. Egy adott i-hez maximum log n ilyen j van, teht ez
csak nlog n trat ignyel. Meg kell gondolni, hogy ezeket az rtkeket tnyleg ki is tudjuk
szmtani O(n log n) idben, ez megint csak dinamikus programozssal megy: ha mr
adott k-ra minden i-re kiszmtottuk az (i, i + 2k 1) krdsekre a vlaszt, akkor ezekbl
k + 1-re minden i-re megkaphatjuk a vlaszt egy sszehasonltssal:
A(i : i + 2k+1 1)

minimuma a min min A(i : i + 2k 1), min A(i + 2k : i + 2k+1 1) lesz.
Htra van mg, hogy ezekbl az eltrolt rtkekbl hogyan vlaszolunk meg konstans
idben egy krdst.
Legyen (i, j) egy krds, s k = blog(j + 1 i)c. Ezt azrt knny kiszmolni,
mert pont a j + 1 i legszignifiknsabb bitjnek
a helye. Nyilvn: min A(i : j) =

min min A(i : i + 2k 1), min A(j 2k + 1 : j) .
Most rtrnk a 1-RMQ feladatra. Legyen k = b(log n)/2c. Osszuk fel az A tmbt
B1 , B2 , . . . , Bdn/ke blokkokra, minden blokk k hossz (kivve esetleg az utolst). Csinlunk egy dn/ke hossz A0 tmbt, ahol A0 (i) tartalmazza a Bi blokk minimlis rtkt.
Szksgnk lesz mg egy dn/ke hossz B tmbre is: B(i) tartalmazza azt a relatv j
indexet a Bi blokkon bell, ahol A((i 1)k + j) felveszi az A0 (i) minimum-rtket.
Egy adott (i, j) krdsre kiszmoljuk a kvetkez rtkeket: i0 az i indexet tartalmaz
blokk neve, j 0 a j indexet tartalmaz blokk neve, l az i-t tartalmaz blokk utols indexe,
f a j-t tartalmaz blokk els indexe, irel az i relatv indexe a Bi0 blokkon bell, vgl
jrel a j relatv indexe a Bj 0 blokkon bell. Megjegyzs: ezeket nem felttlenl kell s
rdemes a krdseknl kiszmtani, az elfeldolgozs sorn is szmthatjuk s trolhatjuk.
Hrom eset van: ha i0 = j 0 , akkor a krdst a Bi0 blokkon bell kell megvlaszolni,
lsd ksbb. Ha j 0 = i0 + 1, akkor a Bi0 blokkon belli (irel , l) s a Bj 0 blokkon belli
(f, jrel ) krdsekre adott vlaszokbl az eredmny knnyen szmthat (a kt minimumrtk minimuma lesz az rtk, a helye is knnyen szmthat). A harmadik esetben
kiszmtjuk RM QA0 (i0 + 1, j 0 1) helyt (a B tmb segtsgvel) s rtkt, ebbl, s az
RM QBi0 (irel , l), valamint az RM QBj0 (f, jrel ) krdsekre adott vlaszokbl a vgs vlasz
ismt knnyen szmolhat.
Mivel az A0 tmb mrete csak O(n/ log n), a fenti msodik megoldssal az A0 -re vonatkoz RMQ krdsek O(1) idben megvlaszolhatk O(n) elfeldolgozs utn. Htra
van mg, hogy az egyes blokkokon belli krdsekre tudjunk vlaszolni. Kt blokkot nevezznk hasonlnak, ha minden i-re a msodik blokk i-edik eleme pont c-vel nagyobb,
mint az els blokk i-edik eleme (ugyanazzal a c egsz szmmal). A kulcs szrevtel az,
hogy kt hasonl blokk esetn minden i j-re az RM Q(i, j) krdsre ugyanaz a vlasz.
Egy blokk normalizlt blokkjnak nevezzk a hozz hasonl blokkok kzl azt, amelyik
els eleme 0. Egy Bi blokk normalizlt indexe kettes szmrendszerben az a k 1 hossz
0-1 sorozat, melynek j. betje 0, ha Bi (j + 1) = Bi (j) 1, s 1 egybknt, ha teht
Bi (j + 1) = Bi (j) + 1. Az elfeldolgozs sorn minden blokkhoz kiszmtjuk a normalizlt indext, s mind a 2k1 indexhez kiszmtjuk a hozz tartoz normalizlt blokk
minden
lehetsges 1 i j k krdshez
a vlaszt a naiv megolds szerint. Mivel csak

k1
2
2
< n normalizlt blokk van, ez n k < n idben s trban kiszmolhat.

83

10.2. ltalnos RMQ feladat visszavezetse az LCA feladatra


Adott A tmbhz definiljuk rekurzvan a Descartes-fjt (Cartesian tree), ami a kvetkez binris fa: a gykr neve legyen k, ha az egsz A tmb (els) legkisebb eleme A(k). A
gykr bal rszfja legyen az A(1 : k 1) rsztmb Descartes-fja, jobb rszfja pedig az
A(k + 1 : n) rsztmb Descartes-fja. Vegyk szre, hogy ha az i nev fa-cscshoz kulcsknt hozzrendeljk az A(i) rtkeket, akkor ez a fa egyszerre lesz a cscsnevek szerinti
binris keresfa s a kulcsok szerint pedig kupac-rendezett fa.

1
2

2 3 4 5 6
1 5 3 7 6

DFa(A[1:8])

7 8 9
9 8 5
DFa(A[1:9])

( i ,A(i))
(2,1)

(2,1)

(4 ,3)
(1,2)
(6,6)
( 3,5)
(8 ,8)
(5,7)
( 7,9)

(1,2)
( 3,5)
(5,7)
( 7,9)

(4 ,3)
(9,5)
(6,6)
(8 ,8)

Elszr azt lltjuk, hogy ez a fa O(n) idben megkonstrulhat. Szpen sorban minden i = 1 . . . n-re megkonstruljuk az A(1 : i) rsztmb Descartes-fjt. Ha i-re mr
megvan, akkor i + 1-re gy jrunk el: Legyenek a gykrtl szigoran jobbra men t cscsai: v0 , v1 , . . . , vt . Nyilvn A(v0 ) A(v1 ) . . . A(vt ). Tegyk fel, hogy k a legnagyobb
olyan index, melyre A(vk ) A(i + 1). Ekkor az j fa gy nz ki, hogy vk jobb gyereke
helyre berakjuk i + 1-et, akinek nem lesz jobb gyereke, a bal gyereke pedig vk+1 lesz (ha
k = t, akkor bal gyereke sem lesz). A k indexet binris keresssel is megkereshetnnk, de
a mr megszokott mdon jobb lesz, ha alulrl felfel egyesvel lpkedve keressk. Legyen
a potencil a gykrtl szigoran jobbra men t cscsainak a szma. Ekkor l keres
lps esetn, a potencil (l 1) + 1 = l + 2 -vel vltozik, a beraks 1 lps, gy az
amortizcis id 3. Innen a teljes fa felptse O(n).
Azt is knny meggondolni, hogy az RM Q(i, j) krdsre adand vlasz a Descartesfban az LCA(i, j) krdsre adott vlasz. Gondoljunk a rekurzv defincira. Kezdetben
i s j egy rsztmbben van. lltsuk meg a rekurzv konstrukcit akkor, amikor nem
lesznek abban. Ekkor egy A(i0 : j 0 ) rsztmb legkisebb elemnek k indexe lesz az aktulis
cscs, s az ettl balra/jobbra ll rsz megy a bal/jobb gyerekbe; aholis i0 i s j 0 j.
Teht egyrszt k lesz a vlasz az LCA(i, j) krdsre, msrszt pedig i k j (mivel

84

most sztvgdnak) s A(k) a minimuma az A(i0 : j 0 ) rsztmbnek, teht minimuma az


A(i : j) rsztmbnek is.

11. Geometriai adatstruktrk


Egy GPS-hez szksges program alapvet feladatait (a Dijkstra algoritmus kivtelvel,
amit mr jl krljrtunk) fogjuk megvalstani ebben a rszben.

A feladat: Adott egy fix trkp s arra vagyunk kvncsiak, hogy hogyan nz ki a trkp
egy adott krnyezetnkben. A krds, hogy hogyan rdemes trolni a trkpet, hogy ezt
a feladatot gyorsan meg tudjuk valstani.
Felttelezsek (egyszerstsek):
1. a trkp objektumai pontokbl s szakaszokbl llnak (krkkel nem rdemes foglalkozni, mert vagy csak akkor akarjuk kirajzolni, ha a kzppontjuk is a tglalapba
esik, vagy pedig egy trkpen csak 2-3 fle mret kr van, amelyek kzppontjait
a megfelelen megnvelt tglalapban kereshetjk),
2. a nevek az objektumokhoz tartoznak, amikor megjelentnk egy objektumot, kirjuk
a hozz tartoz nevet is,
3. a szakaszok nem metszik egymst (ez csak azt jelenti, hogy ha mgis metszenk,
akkor a metszspontot is troland pontnak kell tekintennk),
4. a krds-ablakrl feltesszk, hogy tengelyirny tglalap. Sajnos a valsgban ez
nem tehet fel (ahogy fordulunk, a trkprszlet is fordul), de egyrszt csak ezt van
esly megvalstani, msrszt pedig a fordulsnl gyorsan kell tudnunk forgatni a
kirajzoland rszletet, teht mindenkppen rdemes az adott ferde tglalapot tartalmaz kicsit nagyobb, tengelyirny tglalapot lekrdezni a trkpbl, s a gyors
memriban trolni.
Megjegyzs: Rengeteg tovbbi alkalmazs van, pld. VLSI ramkrk tervezse, CAD rendszerek, ill.
tbb dimenziban VR alkalmazsok (replgp-szimultor, jtkok), vagy akr adatbzisok bizonyos
tulajdonsg elemeinek kilistzsa.

11.1. Egy dimenzis feladatok


Ezeket kt okbl trgyaljuk: egyrszt szksgnk lesz rjuk a kt dimenzis feladatok
megoldsban, msrszt egyszerek, mde jl mutatjk a vizsglt feladattpusoknl hasznlhat/hasznland elveket.

85

I. TROLNI : x1 , x2 , . . . xn R pontokat.
KRDS : P ON T OK(xb , xj ) felsorolni azokat a pontokat, amelyek ebbe az intervallumba esnek, vagyis a vlasz: {xi : xb xi xj }.
Az output hosszt nem tudjuk elre. Jellje ezentl k az output hosszt. A futsi
idket ezentl k s n fggvnyben fogjuk vizsglni. Az ilyen algoritmusokat output
rzkeny algoritmusoknak nevezzk. (Ilyennel mr tallkoztunk, pl. a legrvidebb t
kiratsa is ilyen volt, az O(k) idben futott.)
Megolds: rendezett tmbben troljuk a pontokat; xb -t megkeressk felez keresssel,
majd innentl listzunk, mg xj fel nem rnk.
ID: O(log n + k)
TR: O(n)
FELPTS : O(n log n)
II. TROLNI : I1 , I2 , . . . In R intervallumokat, ahol Ii = [xib , xij ].
KRDS : IN T ERV (x) felsorolni Ii -ket, amelyekre x Ii .
Megolds: intervallum fa. A 2n darab xij , xib kzl legyen x0 a kzps (az n-edik).
Az albbi lpsszmokat/trhelyet clozzuk meg:
ID: O(log n + k)
TR: O(n)
FELPTS : O(n log n)
Rekurzvan ft ptnk:
v0

x0,Lb,L j

x0 -tl jobbra
lv elemek

x0 -tl balra
lv elemek

a v0 gykrben raktrozzuk el az sszes x0 -t tartalmaz intervallumot (s persze x0


rtkt is). Ezen intervallumok halmaza I(v0 ) = {Ii | xib x0 xij }.
a bal rszfban troljuk azokat az intervallumokat, amelyek szigoran balra vannak
az x0 -tl, vagyis: {Ii | xij < x0 }. Itt legfeljebb n2 intervallum lesz.
a jobb rszfban a szigoran jobbra lv intervallumokat troljuk.
a kt rszft rekurzvan ugyangy ptjk fel.
x

x0

Tegyk fel, hogy az IN T ERV (x) krdsnl pld. x x0 . Az x-et tartalmaz intervallumok
ktfajtk lehetnek:
86

azok, amelyek nem rik el x0 -t ezek a bal rszfban lesznek,


azok, amelyek elmennek x0 -ig ezeket a gykrben troltuk.

Megolds: A v0 cscsban x0 rtke mellett I(v0 )-t is troljuk, mgpedig ktszer, egy
Lb (v0 ) s egy Lj (v0 ) tmbben.
Lb (v0 ): x0 -t tartalmaz intervallumok, a bal vgpont szerinti nvekv sorrendben.
Lj (v0 ): x0 -t tartalmaz intervallumok, a jobb vgpont szerinti cskken sorrendben.
Ha x < x0 , akkor Lb elemeit felsoroljuk az els elemtl, amg a bal vgpont x. Ha
pedig x x0 , akkor Lj elemeit felsoroljuk az els elemtl, amg a jobb vgpont x.
Ha x < x0 , akkor rekurzvan folytatjuk a bal fban, ha x > x0 , akkor a jobb rszfban,
ha pedig x = x0 , akkor megllhatunk. Lpsszm v0 -ban: 1 + kv0 , ha kv0 darab kirand
intervallum tallhat itt (azaz I(v0 )-ban). A fa mlysge a felezs miatt legfeljebb
log n lesz. gy a vlaszols sszlpsszma O(log n + k).
A felptsi eljrs lnyege: az elejn rendezzk az intervallumokat kt tmbbe: a
bal vgpont szerint nvekven rendezve, s jobb vgpont szerint cskkenen rendezve.
Egy adott vi cscsnl elszr akr a kt tmb virtulis sszefslsvel, akr a tanult
lineris medins szmtsi mdszerrel megkapjuk az xi kzps szmot. Utna a kt
tmbt lineris idben sztszedjk hrom rszre (az els rszbe kerlnek a bal gyerekbe
tovbbmen intervallumok, a kzpsbe az adott xi -t tartalmazk, a harmadikba a jobb
gyerekbe menk). A kt kapott kzps tmb pontosan Lb s Lj lesz. Egy-egy szinten
az I(v) halmazok diszjunktak, gy a listk sszhossza legfeljebb n. Teht minden jabb
szintet O(n) idben el tudunk kszteni.

11.2. Kt dimenzis feladatok


III. TROLNI : p1 , p2 , . . . pn R2 pontokat, pi = (xi , yi ).
KRDS : Egy adott [xb , xj ] [ya , yf ] tglalapba es pontok felsorolsa, azaz
{pi | xb xi xj s ya yi yf }.
Megolds: Tartomny-fa (range tree).
Els fzis: x koordintk szerint kiegyenslyozott kls trols binris keresft
ptnk (a bels cscsokban tjelzk, a levelekben balrl jobbra nvekven a klnbz
xi rtkek vannak).
Ha v a fa egy cscsa, akkor ASSOC(v) := {pi | xi egy v alatti levlben van}.
Minden v cscshoz az ASSOC(v) halmazt egy L(v) tmbben troljuk, az y koordintk szerint rendezve. (Egy u levlben L(u) az azonos x koordintj pontokat tartalmazza
y szerint rendezve.)
TR: O(n log n) (egy pont minden szinten pontosan egyszer szerepel).
Vlaszol algoritmus: Elszr xb s xj keresse.

87

x b keresse

x j keresse

Legyen vsplit az a cscs, ahol a kt keress elgazik. Egy cscs fontos, ha a vsplit tl az xb keressekor elrt levlbe vezet ton lv olyan cscs jobb gyereke, ahol balra
lptnk, illetve, ha a vsplit -tl az xj keressekor elrt levlbe vezet ton lv olyan cscs
bal gyereke, ahol jobbra lptnk. Ezeken kvl a kt megtallt levl is fontos.
Knny ltni, hogy a kilistzand pontok mind ASSOC(v)-ben vannak valamely fontos v cscsra. (Valamint a definci alapjn az a tny is nyilvnval, hogy ha u s v fontos
cscsok, akkor ASSOC(u) s ASSOC(v) diszjunktak.) Teht minden fontos v cscsban
ki kell vlogatni ASSOC(v) elemeibl a krdsnek megfeleleket.
A fa mlysge log n, gy legfeljebb 2 log n fontos cscs van.
Minden fontos v-re ya -t megkeressk felez keresssel L(v)-ben s kilistzzuk a pontokat yf -ig.
Egy darab v-nl legfeljebb log n + 1 + kv lps kell, ahol kv a v-nl kilistzott elemek
szma.
ID: O(log2 n + k)
FELPTS : O(nlog n) Hint: rendezzk a pontokat x s y koordinta szerint is. Ha
r a gykr neve, nevezzk ezeket AXr ill. AYr -nek, s legyen ar = n. ltalban, ha a fa egy
v cscsnl jrunk, fellrl megkapjuk AXv -t, ami ASSOC(v) az x koordinta szerint
rendezve, AYv -t, ami ASSOC(v) az y koordinta szerint rendezve, s az av = |ASSOC(v)|
mretet. Ekkor v tjelzje az AXv (bav /2c) pont x koordintja lesz. Vgigmenve az AXv
s AYv tmbkn, minden pont x koordintjt ezzel hasonltva a tmbket knnyen
sztszedhetjk a rendezett AXbal(v) s AXjobb(v) , ill. AYbal(v) s AYjobb(v) tmbkre.
Megjegyzs: ez az algoritmus mkdik tbb dimenziban is, ha gy mdostjuk, hogy d
dimenziban az els koordinta szerinti keresfban az ASSOC(v) halmazt rekurzvan egy
d 1 dimenzis tartomnyfban troljuk (a pontok els koordintjt elfelejtve, mint ahogy
eddig is tettk, hiszen a fenti mdszerben az I. feladatnl trgyalt 1-dimenzis tartomnyft
hasznltuk). Ekkor a lekrdezsi id O(logd n + k) lesz, a szksges trhely pedig O(n
logd1 n).
Krds: az O(log2 n + k) idt lehet-e cskkenteni?
A cl : O(log n+k) keressi id, ehhez az kell, hogy a v-nl csak O(1+kv ) idt tltsnk.

88

11.2.1. Javts Kaszkd trolssal


A s B rendezett tmbket szeretnnk trolni, ahol A B.
A

10

19

23

30

37

59

62

70

80 100

nil

10

19

30

62

70

80

H(i) := min{l | B(l) A(i)}, illetve nil, ha nem ltezik ilyen l.


Ha pldul ya = 20, akkor megkeressk az A-ban az els ennl nagyobb-egyenl elemet
(ez A(4) = 23), s H(4) megmutatja, hogy a B(3) = 30 lesz a B-ben az els megfelel
elem.
ASSOC(v) = ASSOC(b(v)) ASSOC(j(v)).
Kaszkd trolsnl minden v cscsban az L(v) mellett egy Hb (v) s Hj (v) pointertmbt is trolunk.
ya -t csak a gykrnl keressk meg felez keresssel, utna Hb vagy Hj mutatja meg
a "helyt" (az els ya -nl nem kisebb elemet).
ID: O(log n + k)
TR: O(n log n)
FELPTS : O(n log n) Hint: Ugyangy, mint az elbb, de amikor kettszednk
egy listt, a Hb s Hj tmbket is feltltjk. Minden megy a trhelyben lineris idben.
Megjegyzs: A d dimenzis feladatra alkalmazva az id O(logd1 n + k)-ra cskken.

11.3. Egy tglalapot metsz szakaszok lekrdezse


Visszatrve az alapfeladatunkra: a krdezett tglalapba (ablak) es pontokat le tudjuk
krdezni, ha tartomny-fban troltuk ket. Hasonl a helyzet az sszes olyan szakasszal,
amelynek legalbb egyik vgpontja az ablakba esik, itt csak kt dologra kell vigyzni:

a szakaszok vgpontjaival egytt troljuk el a szakasz sorszmt is (persze egy pont


sok szakasz vgpontja is lehet, gy igazbl egy-egy ponthoz tartozik egy vdr
(lncolt lista), ami tartalmazza az sszes olyan szakasz indext, amelyeknek vgpontja),
ha egy szakasz mindkt vgpontja az ablakban van, akkor csak egyszer rjuk ki.

89

De persze lehetnek olyan, a tglalapot metsz szakaszok is, melyeknek mindkt vgpontjuk kvl van. Elszr azt a specilis esetet oldjuk meg, amikor minden trolt szakaszunk vzszintes vagy fggleges, s csak a kvetkez fejezetben kezeljk a ferde szakaszok
esett (pld. VLSI tervezsnl ilyenek nincsenek is). Teht most azokat a vzszintes s fggleges szakaszokat szeretnnk kiratni, melyek teljesen tmetszik az ablakot. Az ilyenek
vagy vzszintesek s metszik a jobb oldalt, vagy fgglegesek s metszik a fels oldalt.
Ez a kt feladat nyilvn szimmetrikus, teht elg az els esetet kezelni. Azonban jra
figyelni kell arra, hogy most ki fogjuk vlogatni az sszes vzszintes szakaszt, mely metszi
a jobb oldalt, teht azokat is, amelyek bal vgpontja benne van az ablakban ezeket
azonban mr egyszer kirtuk, nem szabad jra.
Hint a ktszeri kirs megakadlyozsra: egyszer, de kicsit knyelmetlen megolds
lehet, ha egyrszt felvesznk egy n hossz tmbt (n a szakaszok szma) s egy sort. Ha
brmely fzisban megtalljuk az i. szakaszt, akkor megnzzk, hogy a tmb i. eleme 1-e,
ha igen megynk tovbb, ha nem, akkor egyre lltjuk s i-t berakjuk a sorba. A vgn
a sorbl ki tudjuk ratni az sszes megtallt szakaszt, s kzben a tmbt jra le tudjuk
nullzni.
IV. TROLNI : Vzszintes szakaszok a skon.
KRDS : METSZ([x] [ya , yf ]).
VLASZ : felsoroljuk az sszes olyan vzszintes szakaszt, mely metszi a krdezett fggleges szakaszt.
Intervallum-ft ksztnk az x tengelyre es vetletek szerint. DE az eredeti megoldssal ellenttben az I(v) halmazokat nem kt listban troljuk, hanem helyette kt
kupacos keresfban (lsd albb). Az elsben az intervallumokat a bal, a msodikban
a jobb vgpontjuk szerint. A keress majdnem ugyangy megy, mint a hagyomnyos
intervallum-fban, csak amikor az adott v cscs I(v) halmazbl ki akarjuk vlogatni a
minket rdeklket, akkor pld. x < x0 esetn az els kupacos keresfban keressk meg
azokat, akiknek a bal vgpontja a (, x] [ya , yf ] vgtelen tglalapba esik. (Hasonlan, x > x0 esetn, a msodik kupacos keresfban keressk meg azokat, akiknek a jobb
vgpontja a [x, ) [ya , yf ] vgtelen tglalapba esik, ehhez a msodik kupacos keresft
MAX-kupaccal kell definilni.)
Teht a kvetkez feladatot kell mg megoldanunk, melyre a tartomny-fa is megolds
lenne, de most egy mg hatkonyabb megoldst adunk (kisebb trhellyel). Amit meg
tudunk valstani a IV. feladatra (mivel I(v)-bl kirats gy nem lehet O(kv ) idej):
ID: O(log2 n + k)
TR: O(n)
FELPTS : O(n log n)
11.3.1. Kupacos keresfk
V. TROLNI : p1 , p2 , . . . pn R2
KRDS : PONTOK((, x] [ya , yf ]).

90

yf

ya

xj

Megolds: Kupacos keresfa a legszebb szvr adatstruktra.


Elszr egy kis elkszletre van szksgnk, egy j mveletet vizsglunk meg kupacokban.
Adott egy binris kupacrendezett fa, s egy K kulcs, a feladat pedig az, hogy soroljuk
fel (tetszleges sorrendben) az sszes olyan v cscst a kupacnak, amelyre K(v) K.
Megolds: Kir(v0 , K) hvsa, ahol v0 a kupac gykere.
Kir(v, K)
if K(v) K then P RIN T v; Kir(b(v), K); Kir(j(v), K)
19. llts. Ez O(1 + k) idben fut.
Bizonyts: Ha meghvtuk Kir(u, K)-t, akkor vagy u gykr volt, vagy u eleme az
outputnak, vagy p(u) eleme az outputnak, teht k hossz output esetn legfeljebb 2k + 1
hvs lesz (indukcival knnyen lthatan, egy k cscs binris fnak k + 1 fiktv levele
van).
Megjegyzs: Ez persze csak akkor igaz, ha nem rendezve kellenek az elemek, klnben mindenhol
Mintrls kellene.

A Kupacos keresfa egy kiegyenslyozott binris fa, amelynek minden v cscsban egy
q(v) pont s egy y(v) tjelztbla van.
Ez az szvr adatstruktra egyszerre lesz x koordinta szerint kupac, s y koordinta
szerint binris keresfa; pontosabban csak annak hasonmsa, azt a fontos keresfa tulajdonsgot fogja teljesteni, hogy egy adott v cscsnl a bal rszfban csupa olyan pontot
trolunk, melyek y koordintja y(v), a jobb rszfban pedig csupa olyan pontot trolunk, melyek y koordintja > y(v), (de magban a v cscsban trolt q(v) pontnak
semmi kze nem lesz y(v)-hez). Ezektl a q(v) pontoktl eltekintve ez nagyon hasonlt
a mr trgyalt Descartes-fra, ahol az A(i) elem x koordintjnak i-t tekintettk, y
koordintjnak pedig az A(i) rtket.
Felvesznk egy v0 gykeret, q(v0 ) := a legbaloldalibb pont (ha tbb ilyen van, akkor
kzlk brmelyik).
y(v0 ) := y 0 , amelyre S = {p1 , p2 , . . . pn } \ {q(v0 )} halmaznak legfeljebb a fele van az
y = y 0 egyenes felett. Legyen Sa = {pi S | yi y 0 } s Sf = {pi S | yi > y 0 }. Ezeket
rekurzvan ugyangy troljuk a gykr bal, ill. jobb rszfjban.
91

Megjegyzs: ha egy adott pillanatban minden pont y koordintja azonos, akkor az adott
cscsot megjelljk (a keresfnak egy levele lesz), s a pontokat mr egyszeren x szerinti
kupacban troljuk a rszfjban. Ezzel elrjk, hogy a keresfa mlysge akkor is maximum
log n, ha vannak azonos y rtkek, s a keresfa levelein is maximum log n mlysg kupacok
lgnak.
A f fa kiegyenslyozott binris fa, gy mlysge dlog ne. Az ilyen fkat (ez az egsz
fejezetre rvnyes!) trolhatjuk tmbben, gy, mint a kupacokat (legfeljebb 2n hossz
tmb kell). A keresfa levelei alatti kupacokat kln-kln tmbben rdemes ekkor
trolni.

rekurzvan y'
alatti nem q(v)
pontok

rekurzvan y'
feletti nem
q(v) pontok

A Keress gy megy: elszr ya -t s yf -et keressk a fban (amg megjellt cscshoz


nem rnk). A kt specilis fontos cscs az a kt megjellt cscs lesz, ahol a keressek
lellnak.
bels lelg
elemek: ezek y
szerint csupa j
pontok

ya

yf

A keressi utak sorn bejrt cscsokban trolt q(v) pontokat egyesvel leellenrizzk,
hogy benne vannak-e a krdezett tglalapban. Ezeken kvl minden ms j pont valamely
fontos cscs alatt lesz. Radsul egy v fontos cscs alatti minden pont y koordintja
az [ya , yf ] intervallumba esik, gy a fontos cscsok rszfit mr kupacknt kezelhetjk, s
az elbb ltott mdon a Kir(v, x) hasznlatval ki tudjuk rni a j pontokat O(1 + kv )
idben, ahol most kv az output sszes, a v rszfjba es pontjainak szmt jelli.
ID: O(log n + k)
Ez ugyanolyan gyors, mint a tartomny-fa kaszkdolssal, de egyszerbb a megvalsts s kisebb a trigny:
TR: O(n)
FELPTS : O(n log n)
92

11.4. Ferde szakaszok lekrdezse


Ami htravan, az az ablakot teljesen tmetsz ferde szakaszok lekrdezse. Ezt ngy
rszben valstjuk meg, kln-kln lekrdezzk a tglalap ngy oldalt metsz ferde szakaszokat. Szimmetria okokbl nyilvn itt is elg lekrdezni egy adott fggleges szakaszt
metsz ferde szakaszokat.

yf

ya
x

Megjegyzs: Most elszr fogjuk kihasznlni, hogy a szakaszok nem metszhetik egymst.

Megolds: A vetleteket most is mint {I1 , . . . , In } intervallumokat troljuk. Azonban


erre a clra az intervallum-fa jelenleg nem felel meg neknk, ezrt egy jabb, els rnzsre
sokkal rosszabb megoldst kell adnunk erre az egy dimenzis feladatra.
11.4.1. Szakasz-fa
Az n. Locus ( mrtani hely) megkzeltst alkalmazzuk. Vegyk a lehetsges krdsek
tert (itt R, de egy ablaknl pl. R4 lenne), s particionljuk ekvivalencia osztlyokra
(cellkra) gy, hogy kt krds ekvivalens, ha ugyanaz a halmaz a vlasz rjuk. Ha
ezt a partcit hatkonyan tudjuk trolni gy, hogy egy adott krdsre meg is tudjuk
tallni gyorsan az ekvivalencia-osztlyt, akkor az osztlyokhoz felrva a vlaszokat
megoldottuk a feladatot. Ehhez persze eleve kell, hogy az osztlyok szma ne legyen tl
nagy, pl. ablak-krdsekre ez nincs gy.
Felbontjuk a szmegyenest a vgpontok ltal meghatrozott egypont s nylt szakaszokra. Egy-egy ilyen szakaszba azok az x-ek esnek, amelyekre biztosan ugyanaz a vlasz
(az t tartalmaz intervallumok halmaza).
sszesen legfeljebb 4n + 1 darab ilyen szakasz lesz: legfeljebb 2n darab 1 pont s
legfeljebb 2n + 1 darab nylt szakasz (kt trolt intervallum vgpontjai egybe is eshetnek).
Egy kiegyenslyozott binris keresft ptnk, melynek leveleire rrjuk az egypont
s nylt szakaszokat gy, hogy balrl jobbra rendezve legyenek. A fa egy v cscsra definiljuk egyrszt az Int(v) intervallumot, mely a v alatti levelekre rott halmazok unija;
msrszt az ASSOC(v) := {Ii | Ii Int(v), de Ii 6 Int(p(v))} halmazt. A v cscsnl
troljuk ASSOC(v)-t mgpedig egy tmbben (itt mg van nmi szabadsgi fokunk, hogy
milyen sorrendben, ezt a kvetkez alfejezetben ki is fogjuk hasznlni).

93

-)

. ()

.()

.()

20. llts. Egy adott Ii intervallumot a fa egy szintjn maximum ktszer troljuk, gy
az sszes trigny O(n log n).
Bizonyts: Ha Ii egy szinten hromszor lenne trolva, akkor legyenek balrl jobbra a, b, c
a cscsok, amiben troltuk. Mivel Int(a) Ii s Int(c) Ii , ezrt a keresfa tulajdonsgai miatt nyilvn b szljre Int(p(b)) Ii , teht Ii nem lehet benne ASSOC(b)-ben.
Keress: a fban itt is x-et keressk, s a keressi t sorn rintett minden v cscsra
a teljes ASSOC(v)-t kilistzzuk. Teht a keress ideje O(log n + k).
A szakasz-fa elnye az intervallum-fhoz kpest, hogy a keressi t cscsaiban trolt
ASSOC(v) halmazok unija pontosan az, ami a kvnt output, ezekbl itt nem kell
vlogatni. Pont ezrt, ha az ASSOC(v) tmbket alkalmasan rendezzk, akkor mg egy
msik szempont szerint tudunk majd bellk szelektlni.
Meggondolhat, hogy ez is felpthet O(n log n) idben.
11.4.2. Egy fggleges szakaszt metsz ferde szakaszok
A szakaszokat az x tengelyre es vetletk szerint szakasz-fban troljuk, s ebben keressk x-et.

x
Int(v)

94

A keress sorn a fa egy adott v cscsnl ASSOC(v)-ben azok a ferde szakaszok


vannak, amelyek vetlete tartalmazza Int(v)-t, de nem tartalmazza Int(p(v))-t. Ezek
teht mind tmennek az Int(v) (, ) fggleges vgtelen cskon. Mivel nem metszik egymst, gy alulrl felfel egyrtelmen rendezhetk, teht eszerint troljuk ket az
ASSOC(v)-t tartalmaz tmbben. Keresskor felez keresssel knnyen megtallhatjuk
a legals olyat, mely metszi a krdezett [x] [ya , yf ] szakaszt, majd ettl kezdve addig
ratjuk ki ASSOC(v) elemeit, mg metszik ezt a krdezett szakaszt. A v-nl eltlttt id
gy O(log n + kv ), teht az sszes keressi id O(log2 n + k). Az egsz struktra felpthet
O(n log n) idben.

Hivatkozsok
[1] Cormen-Leiserson-Rivest-Stein j Algoritmusok, Mszaki Kiad, 2000.
[2] Aho-Hopcroft-Ullman Szmtgpalgoritmusok tervezse s analzise,
Mszaki Knyvkiad, 1982.
[3] Robert Endre Tarjan Data Structures and Network Algorithms, Philadelphia: Society for Industrial and Applied Mathematics, 1983.
[4] Rnyai-Ivanyos-Szab Algoritmusok, Typotex Kiad, 1998.
[5] D. E. Knuth A szmtgp-programozs mvszete, III. ktet, Mszaki
Knyvkiad, 1994.
[6] L. Lovsz
Algoritmusok bonyolultsga,
http://www.cs.elte.hu/~kiraly/alg.pdf

ELTE jegyzet, 1992. ill.

[7] Berg-Kreveld-Overmars-Schwarzkopf Computational Geometry: Algorithms and Applications, Springer-Verlag, 1997.

95