Adatszerkezetek és algoritmusok előadás jegyzet

1)
Az algoritmusok futási ideje egy bizonyos bemenetre a végrehajtott alapműveletek vagy
lépések száma.

Lineáris keresés (gyakorlati jegyzet)

Bináris keresés (gyakorlati jegyzet)

2)
Beszúró rendezés:

Legjobb eset, ha a bement eleve rendezett.

T(n) = a*n + b
Legrosszabb eset, ha a bemenet fordítva rendezett.
T(n) = a*n2 + b*n + c
3)
Adatszerkezet: adatelemek + kapcsolatok + műveletek + tárolás(reprezentáció,
memóriában/háttértáron történő fizikai tárolás)

Absztrakt adattípus: az adatelemek és a köztük lévő kapcsolatok logikai modellje. Független

az adattárolás fizikai megvalósításától.

Műveletek:
- adatszerkezetek létrehozása
- adatszerkezetek módosítása
 elem hozzáadása
 elem cseréje
 elem törlése
- elem elérése

Közvetlen elérésű memória (RAM): memóriában tárolt minden elem azonos (konstans) idő
alatt hozzáférhető, függetlenül attól, hogy az adott elem elérésekor hány elemet tartalmaz
a memória.
Adatszerkezet reprezentációja lehet:
o folytonos (vektorszerű)
o szétszórt (láncolt)

Adatszerkezetek osztályozása:
Elemek típusa alapján
 homogén (azonos típusú elemek) elemeinek kapcsolata alapján tovább
bontható az osztályozás
o struktúra nélküli
o asszociatív
o szekvenciális
o hierarchikus
o hálós

 heterogén (különböző típusú elemek)

Elemeinek száma alapján

 dinamikus (változhat az elem szám)
 statikus (elemek száma fix)

Bináris keresésnél:
Homogén, rendezett adatok, folytonos reprezentáció.
Halmaz: (gyakorlati jegyzetek)
Egymástól különböző elemekből áll. Absztrakt adattípus.
Tulajdonságai: homogén, dinamikus, struktúra nélküli, folytonos reprezentációval ábrázolt.
Halmazműveletek az unió, metszet, különbség, stb.

Műveletek halmazokkal, mint adatszerkezetekkel:

 létrehozása: folytonos reprezentációval
 módosítása
o elem hozzáadás: unió (egyelemű halmaz hozzáadás)
o elem törlése: különbség (egyelemű halmaz kivonása)
o elem cseréje: különbség, majd unió
 elem elérése: ∈

Multihalmaz: a halmaz olyan módosítása, melyben azonos elemek többször is

előfordulhatnak.

Tömb: (absztrakt adattípus) olyan adattípus, mely előre meghatározott, konstans számú
elemből áll és minden elemet egyértelműen azonosít egy egész számokból álló véges
sorozat.
Sorozat elemeinek száma a tömb dimenziója.
Egydimenziós tömb a vektor, a szám pedig, ami az adott elem tömbön belüli helyzetét
mutatja az index.
Kétdimenziós tömb a mátrix, minden elemet kettő számjegyből álló sorozattal azonosítunk.
A mátrix sorfolytonos reprezentációja esetén megmarad az elemek közvetlen hozzáférése.
Tömb tulajdonságai: homogén, statikus, asszociatív, folytonos reprezentációval ábrázolt.
Ritka mátrix: ha a mátrixban elhelyezkedő elemek nagyrészének az értéke 0. Három soros
reprezentációval ábrázoljuk, ekkor elveszik az elemekhez történő közvetlen hozzáférés.

4)
Verem: olyan speciális absztrakt adattípus, melyben mindössze két módosító műveletet
használhatunk. (gyakorlati jegyzet)
PUSH: ami elemek a verem elejéhez történő hozzáadására szolgál.
POP: ami a verem elején elhelyezkedő elem hozzáférésére és egyben eltávolítására szolgál.
LIFO adattípus: last in, first out.
Tulajdonságai: homogén, dinamikus, szekvenciális, folytonos reprezentációval ábrázolt.
S: olyan verem, ami természetes számokat tartalmaz.
S.top: olyan érték, ami megmondja, hogy a verem az adott időpontban hány elemet
tartalmaz. Ha ez az érték 0, akkor a verem üres. Így létrehozhatunk STACK-EMPTY
műveleteket.
POP-nál ilyenkor alulcsordulás (UNDERFLOW) van.
PUSH-nál ilyenkor túlcsordulás (OVERFLOW) van.
Műveletek:
 adatszerkezetek létrehozása: folytonos reprezentációval
 adatszerkezetek módosítása:
o elem hozzáadása: PUSH
o elem törlése: POP
o elem cseréje: NINCS
 elem elérése: POP

Sor: olyan speciális absztrakt adattípus, melyben mindössze két módosító műveletet
használhatunk. (gyakorlati jegyzet)
ENQUEUE: elemeknek a sor végére történő beszúrása.
DEQUEUE: a sor elején lévő elemhez történő hozzáférésére és egyben az adott elem
eltávolítására.
FIFO adattípus: first in, first out.
Két természetes számot tartunk nyilván: TAIL (hozzáadás) és HEAD (törlés).
Tulajdonságai: homogén, dinamikus, szekvenciális, folytonos reprezentációval ábrázolt.
Reprezentáció megközelítései:
o naív
o sétáló
o ciklikus:
Q.head és Q.tail elem.
DEQUEUE-nél UNDERFLOW.
ENGUEUE-nél OVERFLOW.
Műveletek:
 adatszerkezetek létrehozása: folytonos reprezentációval
 adatszerkezetek módosítása:
o elem hozzáadása: ENQUEUE
o elem törlése: DEQUEUE
o elem cseréje: NINCS
 elem elérése: DEQUEUE

Láncolt lista (linked list): a lista elemei a lista fizikai tárolása során nem követik a listában
szereplő sorrendet, hanem szétszórva helyezkednek el a memóriában. Az elemek
összetettek, az adott elem értékén túl tartalmaznak egy mutatót is, mely a következő elem
memóriabeli helyét tárolja. Tehát minden eleme 2 részből áll:
1. érték 2. mutató (memóriacímet tárol)
HEAD mutató, ami a lista első elemének memóriabeli címét tartalmazza.
Ha a HEAD = NIL, akkor üres a lista.
Tulajdonságai: homogén, dinamikus, szekvenciális, szétszórt (láncolt) reprezentáció.
Típusai: egyirányban láncolt lista, kétirányban láncolt lista, ciklikus lista, multilista.

Kétirányban láncolt lista: minden eleme az adott elem értékén túl tartalmaz még két
mutatót NEXT és PREV. (x.next: x utáni elem, x.prev: x előtti elem).
LIST-SEARCH(L,k): megkeresi a k érték első előfordulását az L listában lineáris kereséssel.
Amennyiben a k érték szerepel a lista elemei között, akkor a visszatérési érték a k értéket
tartalmazó elemre mutató mutató, egyébként pedig NIL.
LIST-INSERT(L,x): beszúrja az adott x elemet az L lista legelső pozíciójába.
LIST-DELETE(L,x): eltávolítja az x elemet az L listából. Elsőnek meg kell keresni az adott érték
memóriacímét hozzá.
Műveletek:
 adatszerkezetek létrehozása: szétszórt (láncolt) reprezentációval
 adatszerkezetek módosítása:
o elem hozzáadása: LIST-INSERT
o elem törlése: LIST-DELETE
o elem cseréje: NINCS
 elem elérése: LIST-SEARCH

5)
Táblázat: olyan összetett adatelemeket tartalmaz, melyek mindegyike alapvetően két
részből áll:
1. kulcs: ami minden esetben egyedi, így azonosítják az elemeket
2. érték: ami maga is összetett, nem szükséges egyedinek lennie
Tulajdonságai: homogén, dinamikus, asszociatív, folytonos vagy szétszórt reprezentáció.
Típusai:
 soros
 önátrendező: ha az adatelemek feldolgozási gyakorisága nagymértékben
eltérő, adatok tárolása láncolt reprezentáció és lineáris keresés
használatával, gyorsan reagál, megtalált elemet mindig előre hozzuk a
legelső pozícióba
 kulcstranszformációs (HASH tábla): amennyiben az U kulcstér nagy (kulcsok
nagy intervallumból kerülnek ki) ezt használjuk közvetlen címzés helyett.
Amikor több kulcshoz tartozik ugyanaz a pozíció azt az esetet ütközésnek
hívjuk. Osztásos módszer: a h hash függvény a k kulcshoz az m különböző
pozíció egyikét rendeli hozzá maradékos osztás segítségével.
h(k) = k mod m
Műveletek:
 INSERT: elem beszúrása
 DELETE: elem eltávolítása
 SEARCH: elem kulcs alapján való megtalálása
Adatszerkezetek létrehozása: folytonos vagy láncolt reprezentációval
Adatszerkezetek módosítása:
elem hozzáadása: INSERT
elem törlése: DELETE
elem cseréje: nem használjuk
Elem elérése: SEARCH

HASH táblázat:
Ütközésfeloldás láncolással műveletek:
Az azonos hash értékekkel rendelkező elemeket 1-1 láncolt listában tároljuk. j-edik
pozícióban egy mutatót találunk, mely azon láncolt lista első elemére mutat, amelyik
mindazon elemeket tartalmazza, mely elemek hash értéke j. Ha nincs ilyen, akkor az értéke
NIL.
Ütközésfeloldás nyílt címzés módszerével:
Minden elem magában a táblázatban tárolódik, ezért a táblázat egy pozíciójában vagy egy
érték található vagy pedig a NIL.
Kereséskor végig nézzük a táblázat elemeit, amíg nem találjuk meg a keresett elemet vagy ki
nem tudjuk jelenteni, hogy az elem nincs benne a táblázatban.
Előnye, hogy nincs szükség más adatszerkezet használatára és mutatók kezelésére.

6)
Fa: adattípus, ami egyrészt a csúcsok halmaza, másrészt a csúcsokat összekötő élek halmaza
alkotja.
Tulajdonsága:
Bármely két csúcsa között pontosan egy út vezet.
Van egy kijelölt csúcs, melyet gyökérnek hívunk.

Fogalmak:
o csúcs
 gyökér
 közbenső elem
 levél
o él
o szülő
o ős (szülő, nagyszülő, ...)
o a fa magassága (ősök számának maximuma)
o gyerek
o leszármazott (gyerek, unoka, ...)
o testvér (két olyan csúcs, melyeknek közös a szülőjük)
o út
o részfa
Tulajdonságai: homogén, dinamikus, hierarchikus, folytonos vagy szétszórt reprezentáció.
Hierarchikus lista: a fa folytonos reprezentációjának az egyik lehetséges módja, mely nem

rendelkezik közvetlen hozzáféréssel. Fenti fáról: .

Fa bejárás: olyan eljárás, mely esetén a fa minden csúcsát pontosan egyszer látogatjuk
meg. Fa bejáró algoritmusok:

Bináris fa: olyan fa, ahol minden csúcsnak legfeljebb két gyereke lehet. Minden gyerek
baloldali vagy jobboldali. Folytonos reprezentációja:

Bináris fa bejárása:
Kifejezésfa: olyan bináris fa, mely minden közbenső eleme egy műveleti jelet tartalmaz és
minden levél eleme egy operandus.

Bináris keresőfa: olyan bináris fa, ami kielégíti azt a feltételt, hogy – Legyen x bináris
keresőfa egy tetszőleges csúcsa. Ha az y csúcs az x csúcs baloldali részfájában található,
akkor y.key < x.key. Ha az y csúcs az x csúcs jobboldali részfájában található, akkor
y.key > x.key.
Műveletek: (gyakorlat jegyzet)
 keresés:

 beszúrás

 törlés
  minimum
 maximum
 megelőző elem
 rákövetkező elem
Műveletek:
 adatszerkezetek létrehozása: szétszórt (láncolt) reprezentációval
 adatszerkezetek módosítása:
o elem hozzáadása: TREE-INSERT
o elem törlése: TREE-DELETE
o elem cseréje: NINCS
 elem elérése: ITERATIVE-TREE-SEARCH

7)
Egy bináris fa kiegyensúlyozott, ha bármely csúcs esetén a baloldali és a jobboldali részfa
magassága közötti különbség maximum.

Kiegyensúlyozott bináris keresőfa esetén a keresés, a beszúrás és a törlés művelete is

logaritmus időben ( ) megvalósítható.

AVL fa: olyan kiegyensúlyozott bináris keresőfa, mely elemek hozzáadása vagy törlése után,
szükség esetén visszaállítja a kiegyensúlyozottságot.
Műveletek:
 adatszerkezetek létrehozása: folytonos vagy szétszórt (láncolt)
reprezentációval
 adatszerkezetek módosítása:
o elem hozzáadása: TREE-INSERT + REBALANCE
o elem törlése: TREE-DELETE + REBALANCE
o elem cseréje: NINCS
 elem elérése: ITERATIVE-TREE-SEARCH
Minden csúcsához tartozik egy szám, ami a jobboldali és a baloldali részfa magasságának a
különbsége. Ezt a számot egyensúly-faktornak hívjuk.
 AVL fa módosítás esetén forgatásra is szükség lehet, hogy a fa visszanyerje a
kiegyensúlyozott alakját. Erre csak akkor van szükség, ha valamely csúcsnak az egyensúly-
faktor kilép a [-1; 0; 1] intervallumból. Ekkor 4 eset fordulhat elő:

1. 2.

3.

4.
8)
Piros-fekete fa: a bináris keresőfa minden csúcsához hozzárendel egy plusz bit információt,
a csúcs színét, ami lehet piros vagy fekete.

Módosítás után szükség lehet átszínezésre és elforgatásra, hogy visszaállítsuk a fa

megfelelő alakját.
Minden csúcsnál a következő adatokat tartjuk nyilván:
kulcs | szín | baloldali gyerek | jobboldali gyerek | szülő.
Ha nincs szülő vagy gyerek, akkor az adott érték NIL.
Tulajdonságai:
 minden csúcs piros vagy fekete
 gyökér fekete
 minden NIL levél fekete
 minden piros csúcsnak mindkét gyereke fekete
 minden csúcsra igaz, hogy az alatta lévő levelekhez vezető utakon
ugyanannyi fekete csúcs található.
LEMMA:
Egy n közbenső csúccsal rendelkező piros-fekete fa maximális magassága 2*log 2(n+1).
Műveletek:
 adatszerkezetek létrehozása: folytonos vagy szétszórt (láncolt)
reprezentációval
 adatszerkezetek módosítása:
o elem hozzáadása: TREE-INSERT + RECOLOR + ROTATE
o elem törlése: TREE-DELETE + RECOLOR + ROTATE
o elem cseréje: NINCS
 elem elérése: ITERATIVE-TREE-SEARCH
REBALANCE helyett RECOLOR + ROTATE van, mivel a piros-fekete fák nem feltétlen
kiegyensúlyozottak, ezért átszínezéssel és forgatással tehetjük azzá őket.
Forgatás:
Beszúrás:
Mindig piros csúcsot szúrunk be.
A gyökér mindig fekete kell maradjon.
Minden piros csúcsnak mindkét gyereke fekete. Ilyenkor 3 eset lehetséges, ahol z a
problémás csúcs:
1. eset: z nagybácsikája piros
 2. eset: z nagybácsikája fekete és háromszögünk van

3. eset: z nagybácsikája fekete és egyenesünk van

9)
Alapvető különbség a háttértárak és a belső memóriája (RAM) között, hogy a háttértárak
jóval nagyobb kapacitással rendelkeznek, olcsóbbak, kikapcsolás vagy áramszünet esetén is
megőrzik az adatokat, bár nagyságrendekkel lassabbak, mint a RAM.
Winchestereket úgy gyorsították meg, hogy egy időben több helyen is olvassák a lemezeket.
Egy-egy ilyen egyszerre beolvasott adatot lapnak hívunk és az eljárást, amivel a lapokat a
memóriában töltjük lapozásnak nevezzük.
Az adatok betöltése a háttértárból a memóriába tovább tarthat, mint az feldolgozása, ezért
két összetevője van a futási időnek:
 háttértárhoz történő hozzáférések száma
 CPU számítási ideje

B-fa: olyan keresőfák, melyeket a merevlemezes háttértárakon történő adatok kezelésére

alakítottak ki. Nem bináris fák. Céljuk a lapozások számának minimalizálása. Magasságát az
határozza meg, hogy hányszor fordulunk a háttértárhoz.
Tipikus esete, amikor olyan nagyméretű adattal dolgozunk, ami nem fér el egyszerre a
RAM-ban. Ekkor a B-fa algoritmusa bemásolja a háttértárról a belső memóriába azokat az
adatrészeket, amelyek szükségesek az aktuális feladathoz, majd visszaírja azokat a
háttértárba.
A RAM-ban mindig konstans számú lap található, így mérete nem korlátozza a teljes B-fa
méretét.
Fa adatszerkezet esetén elágazási tényezőnek nevezzük a csúcsok gyermekeinek számát.
Amennyiben ez változó, átlagos elágazási tényezőről beszélünk.
Nagy elágazási tényező csökkenti a fa magasságát, ezáltal a háttértárban történő olvasások
számát 1-1 kulcs megkeresésekor.

TÉTEL:
Legyen n ≥ 1 természetes szám. Bármely n kulcsot tartalmazó, t ≥ 2 minimális fokszámú B-fa
n+1
esetén a fa magassága h ≤ log t 2 .
Műveletek:
 adatszerkezetek létrehozása: B-TREE-CREATE
 adatszerkezetek módosítása:
o elem hozzáadása: B-TREE-INSERT
o elem törlése: B-TREE-DELETE
o elem cseréje: NINCS
 elem elérése: B-TREE-SEARCH
A B-TREE-SEARCH eljáráshoz lapozás szükséges, ahol h a fa magasságát, n
pedig a kulcsok számát jelöli. Mivel x.n < 2*t, a 2-3 sorokban található while ciklus
lépésszáma minden csúcsra, így a teljes futási idő .
Beszúrás:
10)
Irányítatlan gráf: a csúcsok és élek véges halmazából áll. Az élek halmazát a csúcsok
elemeiből alkotott rendezetlen párok alkotják.
Szomszédsági lista:

Szomszédsági mátrixa: |V|2

Irányított gráf: az élek halmazát alkotó csúcspárok rendezettek.

Szomszédsági lista:

Szomszédsági mátrixa: |V|2

Ritka gráfok esetén, amennyiben |E| jóval kevesebb, mint |V|2 a szomszédsági lista
(könnyű végigmenni az egy adott csúcshoz tartozó összes élen) ajánlott.
Sűrű gráfok esetén, amennyiben |E| számossága közel van |V|2-hez a szomszédsági mátrix
(könnyű annak ellenőrzése, hogy 2 csúcs között vezet-e él) ajánlott.

Szélességi bejárás és keresés:

Csúcsok lehetnek fehérek, szürkék vagy feketék.
Az algoritmus használ egy sor adatszerkezetet (Q), mely a szürke csúcsokat tartalmazza.
Mélységi bejárás és keresés:
Csúcsok lehetnek fehérek, szürkék vagy feketék.
Az algoritmus verem adatszerkezetet (S) használ, mely a szürke csúcsokat tartalmazza.

Mindkét keresés és bejárás teljes futási ideje:

11)
A párhuzamos algoritmusok végrehajtásához szükségesek párhuzamos számítások, ezeket
több processzor maggal rendelkező gépeken tudjuk végrehajtani.
Ezen számítógépek esetén minden processzor mag egy közös memórián osztozik.
Az ilyen jelenlegi processzorokat nevezzük többmagos processzornak (közös memórián
osztozik, de párhuzamos számításokat végez).

Szekvenciális algoritmusokat egymagos processzort használó gépekre fejlesztettek ki, így

egy lépésben egy művelet volt végezhető.

Ellentétje a párhuzamos algoritmusok, melyek többmagos processzorokkal valósítanak

meg párhuzamos számításokat, ezzel csökkentve a futási időt.

Dinamikus többszálú algoritmusok: a felület tartalmaz egy ütemezőt, mely automatikusan

összehangolja a számításokat. Két megoldást támogat:
 1. beágyazott párhuzamosság (nested parallelism):
Lehetőséget ad alprogramok futtatására, miközben a főprogram is tovább fut. Így egy
időben hajt végre több programrészt.
Algoritmusa - Fibonacci számok:

2. párhuzamos ciklusok (parallel loops)

Minden egyes lépést egyszerre hajt végre, egyidőben számolja ki az értékeket a
ciklusváltozó minden egyes értékére.

A dinamikus többszálúság használatakor plusz utasításokkal egészítjük ki a szekvenciális

programunkat. Ilyenek:
o parallel
o spawn
o sync
Munka és idő:

Futási idő:
Hozzáférési verseny (determinacy race) alakul ki abban az esetben, amikor több,
párhuzamosan futó szálon ugyanahhoz a memóriarészhez próbálunk meg hozzáférni úgy,
hogy legalább egy szál írni próbálja az adott memóriarészt.

Többszálú mátrix szorzás:

Eredeti összefésüléses rendezés | Többszálú összefésüléses rendezés

12)
Polinomiális idejű algoritmusok: n méretű bemeneten futási idejük a legrosszabb esetben
is O(nk), valamely k konstanssal.

P probléma:
A P osztály a polinom időben megoldható problémákból áll, azaz olyan problémákból,
melyekhez létezik olyan k konstans, hogy a probléma n hosszú bemenet esetén O(nk) idő
alatt megoldható.

NP probléma:
Az NP osztály olyan problémákból áll, amelyek polinom időben ellenőrizhetők.

NPC probléma:
Az NP-teljes problémák osztályát jelöli. Ha az NP-teljes problémák közül, akár csak egy is
megoldható polinomiális időben, akkor minden NP-beli problémamegoldható polinomiális
időben.

Optimalizálási probléma:
Minden megengedett megoldáshoz egy érték tartozik, feladata olyan megengedett
megoldás megtalálása, amelyhez a legjobb érték van hozzárendelve.

Döntési problémák:
NP-teljességet itt alkalmazzuk. A válasz egyszerű, lehet igen vagy nem is.
Legrövidebb út | Leghosszabb út
 Euler-kör
G=(V,E) összefüggő, irányított gráf
Euler-köre egy olyan kör, amelyben
pontosan egyszer szerepel G minden éle.
A G gráf pontosan akkor tartalmaz
Euler-kört, ha minden csúcsából páros
számú el indul ki.
Megtalálására algoritmus létezik.
Hamilton-kör
G=(V,E) gráf Hamilton-köre egy olyan
kör, amelyben pontosan egyszer szerepel
minden csúcs.
NP-teljes probléma, hogy egy adott
gráfban található-e ilyen kör.

Karp-redukció: Polinom idejű visszavezető algoritmus.

Eljárása:
Legyen adott egy A döntési probléma, amit polinom idő alatt szeretnénk megoldani.
Van egy B döntési probléma, amit már meg tudunk oldani polinom idő alatt.
Végezetül legyen egy olyan eljárásunk, ami az A probléma minden α esetét átalakítja a B
probléma egy β esetévé, úgy, hogy
az átalakítás polinom idő alatt megtörténik,
a válasz minden esetben azonos lesz, azaz β pontosan akkor igaz, amikor α is igaz és β
pontosan akkor hamis, amikor α is hamis.
NP-teljesség:
A B probléma NP-nehéz, ha minden NP-beli A probléma esetén létezik az A problémának
Karp-redukciója a B problémára.
Egy probléma NP-teljes, ha
 NP-beli (igazolására polinom idejű ellenőrző algoritmus)
és
 NP-nehéz (igazolására Karp-redukció és egy igazoltan NP-teljes probléma)

13)
Leszámláló rendezés: n bemeneti elem mindegyike 0 és k közötti egész szám.

Algoritmus futási ideje:

Radix sort:
Adott n darab d-számjegyű szám, amelyben minden számjegy k lehetséges értéket vehet
fel, a RADIX-SORT helyesen rendezi ezeket a számokat időbe, ha a rendezés
stabil, akkor időt használ.