Adatszerkezetek. Készítette: Csatlós István 2005-ben

Adatszerkezetek Készítette: Csatlós István 2005-ben

Alapfogalmak Elmélet Rendszer Közös s ismérv alapján összetartozó,, egymással meghatározott kapcsolatban lévől elemek jól j körülhatárolt együttese. A valós s világ g rendszerei komplexek, nyíltak, és s dinamikusak. 1. Komplex: Egy elemnek sok tulajdonsága lehet, valamint a közöttk ttük lévő kapcsolatok igen bonyolultak lehetnek. 2

Alapfogalmak 2. Nyílt: A valós s világ g rendszerei nem önmagukban létezl tezők, közöttk ttük különféle kapcsolatok állnak fenn. 3. Dinamikus: A fennáll lló kapcsolatok és a viselkedési si módok m az időben folyamatosan változnak, v s a rendszer egyes elemei máskm sképpen viselkednek egymással szemben is. Elmélet 3

Alapfogalmak A valós s világ g leegyszerűsítése se modellalkotással törtt rténik. Absztrakció Olyan tevékenys kenység, amikor az egyes, konkrét t (vizsgált) rendszernél l kiemelünk néhány n ny közös k tulajdonságot, s a többi t (számunkra lényegtelen) tulajdonsággal nem foglalkozunk. Elmélet 4

Alapfogalmak Modell Beszélhet lhetünk adatmodellről és s funkcionális modellről. l. 1. Adatmodell: A teljes modell statikus része. Fix adatokkal dolgozik. Benne a rendszer elemeinek tulajdonságait adatokkal jellemezzük. Ezzel foglalkozik az adatszerkezetek tantárgy! Szokás s logikai, vagy absztrakt adatszerkezetnek is nevezni. Elmélet 5

Alapfogalmak 2. Funkcionális modell: Minden esetben a viselkedést st modellezi. Dinamikus a jellemzők k időbeli változv ltozása miatt. Ezzel foglalkozik az algoritmizálás és a programozás s tantárgy. Szokás fizikai, vagy tárgyszerkezetnek t is nevezni. E szerkezetek jelennek meg a memóri riában, illetve a hátth ttértárolókon. Elmélet 6

Adatszerkezetek csoportosítása sa 1. Lehet statikus, vagy dinamikus. Statikus adatszerkezet esetén n az adatelemek száma az időben nem változik, dinamikusnál l viszont igen. Elmélet 2. Tovább bbá lehet homogén n (egynemű), vagy heterogén n (összetett,( eltérő típusú). Ezeket tovább csoportosíthatjuk thatjuk logikai (absztrakt) és fizikai (tárgy) adatszerkezetekre. 7

Adatszerkezetek csoportosítása sa Elmélet Homogén n logikai adatszerkezetek típusai és s megvalósításuk suk tárgyszerkezetekkel: 1. Struktúra ra nélkn lküli li adatszerkezetek halmaz, ill. multihalmaz. 2. Asszociatív v adatszerkezetek tömb, ill. táblázat. 3. Szekvenciális adatszerkezetek lista, verem, sor, sztring. 4. Hierarchikus adatszerkezetek fa. 5. Hálós s adatszerkezetek háló. 8

Adatszerkezetek csoportosítása sa Elmélet Heterogén n logikai adatszerkezet és megvalósítása sa tárgyszerkezettel: t 1. Rekord a RAM-ban (ez a logikai). 2. Rekord a fájlban f (ez a tárgyszerkezet) t A két k t rekordfogalom nagymért rtékben eltér egymást stól! Ábrázolása mindig folytonosan törtt rténik, míg m g a homogén adatszerkezetek ábrázolhatók k szétsz tszórt módon is. 9

Műveletvégzés s a logikai adatszerkezetekkel Elmélet 1. Létrehozás E művelet m során n dől d l el az adatszerkezet felépítése és s a legfontosabb jellemzői. E művelet m elvégz gzése után n vihetünk fel adatelemeket. 2. Bővítés E művelet m során n az adatelemek száma nő, n új j adatelemek kerülnek be a szerkezetbe. (Csak dinamikus adatszerkezet bővíthetb thető!) 10

Műveletek log. adatszerkezetekkel Elmélet 3. Törlés Beszélhet lhetünk logikai és fizikai törlt rlésről. Logikai: az adatelemek száma nem változik, csak valamilyen technikával egy, vagy több t adatelemet érvénytelenítünk. nk. Fizikai: az adatelemek darabszáma csökken, ténylegesen t eltávol volítjuk őket. 4. Csere Az adatelemek száma nem, csak az értékük k változik. v (A log. törlt rlés ált. lt.-ban egy értékcsere!) 11

Műveletek log. adatszerkezetekkel Elmélet 5. Rendezés Rendezési algoritmusok ismerete szüks kséges az alkalmazásához. 6. Keresés Annak a kérdk rdésnek az eldönt ntése a feladat, hogy egy jól j definiált elem benne van-e e az adatszerkezetben, vagy nincs. Fajtái: teljes-,, lineáris ris-,, bináris keresés. s. 7. Elérés Olyan művelet, m amely bármely elem megfogását, elérését jelenti. Fajtái: soros, közvetlen. k spec. 12

Műveletek log. adatszerkezetekkel Elmélet 8. Feldolgozás az adatszerkezet minden elemén n valamilyen művelet m elvégz gzése történik. Speciális művelete m az újrafeldolgozás, amikor egy új tárolóterületen ismét t létrehozzuk l az adatszerkezetet. Ez törtt rténhet változtatás s nélkn lkül, l, vagy változtatv ltoztatással is. Általában az utóbbi valósul meg, hiszen a műveletnek m pont ez a célja. c (E művelet m csak fiz. szerk.-nél l létezik!) l 13

Adatszerkezetek ábrázolása Mindig a tárgyszerkezeten t alapszik. Azt értjük k alatta, hogy hogyan jelenítj tjük meg az egyes adatelemeket a memóri riában. Lehetséges ábrázolási módok m a következők: k: 1. Folytonos ábrázolás 2. Szétsz tszórt ábrázolás Elmélet 14

Elmélet Adatszerkezetek ábrázolása Folytonos ábrázolás s jellemzői: Minden adatelem számára azonos hosszúságú tárhelyet foglalunk le a memóri riában. Egy tárhely t annyi bájtbb jtból áll, hogy az adott adatszerkezet minden adateleme megjeleníthet thető legyen. Az egyes tárhelyek t folytonosan összefüggő tárterületet alkotnak. Így, ha ismerjük k az 1. tárhelyet, t s a tárhelyek t azonos, közös k s méretm retét, t, akkor ebből l bármelyik b tárhely címe c meghatározhat rozható! 15

Elmélet Adatszerkezetek ábrázolása Folytonos ábrázolás s jellemzői: Az adatelemek elhelyezése egy-egy tárhelyen minden konkrét adatszerkezet esetében egy leképez pezéssel törtt rténik, amely megmondja, hogy az adatelemeket hová kell elhelyezni (s esetleg azt is, hogy hogyan) az adatszerkezet tárhelyén. Hogyan hajthatók k végre v ezen a tárolt rolási módon a megismert műveletek? m 16

Adatszerkezetek folytonos ábrázolása 1. Létrehozás Tárhely lefoglalását jelenti. 2. Bővítés E művelet m egyszerűen en végrehajtható akkor, ha a feltölt ltés (vagyis a leképez pezés) olyan, hogy folytonosan tölti t fel a rendelkezésre álló tárhelyet. A művelet m adatelemek mozgatásával is együtt járhat. j Elmélet 17

Adatszerkezetek folytonos ábrázolása 3. Törlés Logikai változata v megvalósíthat tható adatcserével akkor, ha egy olyan adott bitkombináci cióra állítjuk be a tárhelyet, t amelynek nincs gyakorlati jelentősége. Fizikai változatának alkalmazása során n az utolsó adatelemmel felülírjuk a rákövetkezőt. t. Elmélet 4. Csere Az adott tárhelyet t ilyenkor egyszerűen en felülírjuk az új j adattal. 18

Adatszerkezetek folytonos ábrázolása 5. Rendezés a folytonos ábrázolás esetén n bármelyik b ismert rendezési algoritmus alkalmazható. 6. Keresés Mindhárom tanult keresési si eljárás s alkalmazható. 7. Elérés Minden tárhelyet t közvetlen k módon el tudunk érni. Elmélet 8. Feldolgozás Az összes ismert keresési si eljáráson és s a közvetlen k elérésen alapul. 19

Adatszerkezetek folytonos ábrázolása Előnyei: Gyors feldolgozás. Statikus adatszerkezetek esetén n jól j alkalmazható. Hátrányai: Elmélet Lassú utasítás s végrehajtv grehajtás. Ilyenkor a tárhelyet t előre le kell foglalni, s emiatt nincs lehetőség g a dinamikus memóriakezel riakezelésre. 20

Adatszerkezetek szétsz tszórt ábrázolása Szétsz tszórt ábrázolás s jellemzői: Az egyes tárhelyek t mérete m különbözhet egymást stól. A tárhely t egy részr szén n adatelemek (adatrész), másik m részr szén n egy, vagy több t mutató találhat lható,, amely tárct rcímet tartalmaz. Lehetővé teszi a dinamikus tárkezelt rkezelést. Elmélet A tárhelyek t nem folytonosan, hanem szétsz tszórtan helyezkednek el. 21

Elmélet Adatszerkezetek szétsz tszórt ábrázolása Szétsz tszórt ábrázolás s típusai: t 1. Egyirányban láncolt l lista 1. 2. Cirkuláris ris lista 2. 3. Kétirányban láncolt l lista 3. 4. Multilista 4. Adatszerkezetek reprezentáci ciója: : az adatszerkezet tárolt rolási módjm djának és s a leképez pezésének az együttes megadása. Adatszerkezetek implementáci ciója: amikor egy adott programozási nyelven leprogramozzuk az adatszerkezetet. 22

Egyirányban láncolt l lista Adat Mut. Adat Mut. Adat NIL Fej Fej az 1. tárhely t címét c t tartalmazza. Mutató mindig a következk vetkező tárhely címére mutat. NIL olyan mutató,, amely azt jelzi, hogy nincs további tárhely. t Elmélet Hogyan hajthatóak ak végre v ebben az ábrázolási módban m a műveletek? m 23

Cirkuláris ris és s kétirk tirányban láncolt l lista Fej Adat Mut. Adat Mut. Adat Mut. Adat N. M2 Adat M1 M2 Adat M1 N. Fej Fej Elmélet Hogyan hajthatóak ak végre v ezekben az ábrázolási módokban m a tanult műveletek? 24

Multilista Elmélet Különlegessége az, hogy az adatrésze összetett adatelemeket tartalmaz. Megvalósítása sa 3 módon m törtt rténhet: 1. Két t egymást stól l független f lista láncoll ncolása. 2. Egy adott adatért rtékre törtt rténik meg a láncolás. Annyi részlr szlánc épül l fel, ahány különböző értéke van az adatelemnek. Fejből l annyi van, ahány részlr szlánc. 3. Az adatelem 1. része r jelző funkciót t tölt t be, azt mutatja meg, hogy az adat valóban adat-e, vagy egy új j lánc l kezdete, tehát t fej. 25

Szabad helyek problémája Elmélet 1.Folytonos Folytonos tárolt rolás s esetén Csak fizikai törlt rlést engedünk nk meg, s összegyűjtjük k a szabad tárhelyeket. t Vagy csak logikai törlt rlést engedünk nk meg, s csak bizonyos időközönk nként nt hajtunk végre v szabad tárhely t gyűjt jtögetést. Megvalósítása sa 2 módon m törtt rténhet: 1. Szemétgy tgyűjtési technikával (Garbage Collection), mely a hátth ttérben, és s bizonyos időközönk nként nt aktivizálódva törtt rténik. 2. Szabad helyek nyilvántart ntartása technika. 26

Szabad helyek problémája Elmélet 2.Sz Szétszórt tárolt rolás s esetén A tárhelyeket t előre lefoglaljuk, és készítünk egy egyirány nyú listát t a szabad helyekről. l. Logikai törlt rlés s itt is lehetséges. Megvalósítása sa itt is 2 módon m törtt rténhet: 1. Szemétgy tgyűjtési technikával (Garbage Collection), mely a hátth ttérben, és s bizonyos időközönk nként nt aktivizálódva törtt rténik. 2. Szabad helyek nyilvántart ntartása technika alkalmazásával (szabad helyek listája). 27

Elmélet I. Homog Tárgyszerkezetek Homogén n adatszerkezetek 1. Struktúra ra nélkn lküli li adatszerkezetek Közös s jellemzőjük: nincs bennük k semmilyen kapcsolat az adatelemek között, k és s bármilyen b átrendezés s után n ugyanolyanok maradnak (dinamikusak). Típusai: 1. Halmaz, vagy Set: melyben, minden elem értéke különbk nböző. 2. Multihalmaz, vagy Multiset, ill. Bag: melynek, lehet azonos értékű-, és s ismétl tlődő 28

Elmélet Tárgyszerkezetek I. Homogén n adatszerkezetek 1. Struktúra ra nélkn lküli li adatszerkezetek Speciálisan értelmezett műveletei: m 1. Unió 2. Metszet 3. Különbség 4. Tovább bbá a Multihalmaz esetén n az ismétl tlődés s miatt az előfordul fordulási számot is figyelembe kell venni. Ennek az adatszerkezetnek ott van alapvető szerepe, ahol az adatelemek valamikor, valahogyan előállnak. llnak. 29

Elmélet I. Homog Tárgyszerkezetek Homogén n adatszerkezetek 2. Asszociatív v adatszerkezetek a TÖMB Ezek a halmaz adatszerkezetekből úgy keletkeznek, hogy létrehozunk l egy osztályoz lyozást. Az így nyert elemekből részhalmazokat hozunk létre. l E részhalmazok, vagy diszjunktak, vagy átfedőek, ek, és s lehetnek közöttk ttük k 1 eleműek ek is. Nem dinamikusak! Típusai: 1. Egydimenziós s tömbt 2. Többdimenziós s tömbt 30

Elmélet Tárgyszerkezetek Hogyan hajthatók k végre v ezen az adatszerkezeten a tanult műveletek? m 1. Létrehozás: a dimenziósz szám és s az indextartomány ny rögzr gzítésével létrehozzuk l a struktúrát. t. (A gyakorlatban ez azt jelenti, hogy egymásut sután n felvesszük k az elemeket!) 2. Bővítés: új j elem felvétel telével törtt rténik. 3. Törlés: a logikai változata v elemcserével könnyen megvalósíthat tható,, fizikai törlt rlés pedig nincs. 4. Csere: van, elemcserét t jelent. 31

Elmélet Tárgyszerkezetek 5. Rendezés: általában csak 1 dimenzióban van értelme, több t dimenzióban nem értelmezzük. 6. Keresés: s: hasonlóan an kezelendő,, mint a rendezés. 7. Elérés: közvetlen k módon m törtt rténik (cím!). 8. Feldolgozás: alapja a közvetlen k elérés, 1 dimenzióban esetleg a keresés. s. Az adatszerkezet ábrázolása folytonosan történik, melyet vektorszerűnek hívnak! h Több dimenzióban el kell dönteni, d hogy sor-,, vagy oszlopfolytonosan törtt rténjen! 32

Tárgyszerkezetek Elmélet A tömb t adatszerkezet a programozásban alapvető jelentőségű,, mert a segíts tségével minden más m s adatszerkezet ábrázolható! Ezért vizsgáljunk meg néhány n ny gyakorlati problémát, melyek a tömbt mbök k segíts tségével leprogramozhatók. A konkrét t magas szintű programozási nyelvek közül k l a feladatok megoldása során a C nyelvet használjuk, de nem térünk t ki a nyelv sajátoss tosságaira, hanem csak a megoldási algoritmusra koncentrálunk! 33

Tárgyszerkezetek 1. Gyakran találkozhatunk lkozhatunk azzal a problémával, hogy egy halmaz elemei közül ki kell választanunkv egyet, valamilyen tulajdonsága alapján! Pl.: egész számokat tartalmazó tömb elemei közül, k -melyről l nem tudjuk, hogy rendezett-e- ki kell választanunk v a legkisebbet és s a legnagyobbat. Gyakorlat A feladat megoldásának algoritmusa, illetve programkódja C ben a következk vetkező: 34

Tárgyszerkezetek Gyakorlat #define TOMBMERET 100 int tarolo[tombmeret]; int min, max; min=tarolo[0]; for(i=1;i<tombmeret;i++) if(min>tarolo[i]) min=tarolo[i]; max=tarolo[0]; for(i=1;i<tombmeret;i++) if(max<tarolo[i]) max=tarolo[i]; 35

Gyakorlat Tárgyszerkezetek 2. Következő feladatainkban azt szeretnénk nk eldönteni nteni,, hogy egy adott elem megtalálhat lható-e e a tömbben, t s ha igen, akkor ő hányadik elem? E feladatok megoldása a különfk nféle keresési si algoritmusokkal lehetséges. A keresések sek legegyszerűbb módszere m a lineáris keresés,, melynek lényeg, l hogy sorban vesszük k a tömbelemeket, t s közben k megvizsgáljuk őket, hogy megegyeznek-e a keresett elemmel. A keresés s leáll ll az első megtalált lt elemnél, l, vagy a tömb t 36

Tárgyszerkezetek Gyakorlat #define TOMBMERET 100 int tarolo[tombmeret]; int e; int linearis(int e) { for(int i=0;i<tombmeret,i++) if(e==tarolo[i]) return i; return 1; } 37

Tárgyszerkezetek Gyakorlat Egy másik m igen egyszerű keresési si eljárás s a bináris keresés,, melynek alapfeltétele, tele, hogy a vizsgált tömb t rendezett legyen. Lényege: a keresett értéket elősz ször r a tömb t középső elemével hasonlítjuk össze. Ha egyenlőek, ek, akkor vége v a keresésnek. snek. Ha a keresett elem kisebb, mint a középsk pső, akkor a tömb t alsó felében folytatjuk tovább a keresést, st, egyébk bként pedig a felső felében. Az eljárás s ezután n rekurzív v módon m folytatódik tovább a kiválasztott térft rfélben. 38

Tárgyszerkezetek Gyakorlat int binaris(int also, int felso, int e) { int kozepso; while(also<felso+1) { kozepso=(also+felso)/2; if(e==tarolo[kozepso]) return kozepso; if(e>tarolo[kozepso]) also=kozepso+1; else felso=kozepso-1; } return 1; } 39

Gyakorlat Tárgyszerkezetek 3. Rendezéses feladatok, melynek megoldása során n egy (vagy több) t tömb t elemeit szeretnénk nk növekvn vekvő (vagy csökken kkenő) ) sorrendbe állítani. Sokféle rendezési algoritmus létezik. l Az egyszerűbbt bbtől l haladunk a bonyolultabbak felé.. Egy-egy adott probléma során mindig a rendelkezésre álló erőforr források és s a konkrét t cél c l elérése határozz rozzák k meg, hogy melyik módszert m célszerc lszerű alkalmazni. Elsőként az egyszerű cserés rendezéssel fogunk megismerkedni. 40

Gyakorlat Tárgyszerkezetek Legyen az adatok száma n (TOMBMERET). A feladat az adatok növekvn vekvő sorrendbe rendezése. A rögzr gzített i-edik i elemet összehasonlítjuk a nála n nagyobb indexű elemekkel. Ha a vizsgált elem kisebb az i-edik elemnél, l, akkor az elemeket felcserélj ljük k egymással. E algoritmust 2 egymásba ágyazott száml mlálós s ciklussal valósítjuk meg. HátrH tránya, hogy csak rendezett halmaz elemein működik. m Hasonlóan, an, mint a következk vetkező,, a közvetlen beszúrásos sos rendezés. 41

Gyakorlat Tárgyszerkezetek void csere(tomb a, int n) { int atmeneti, i, j; for(i=0;i<n-1;i++) { for(j=i+1;j<n;j++) { if(a[i]>a[j]) { atmeneti=a[i]; a[i]=a[j]; a[j]=atmeneti; } } } } 42

Gyakorlat Tárgyszerkezetek A beszúrásos sos rendezés s alapgondolata a következő: : vegyük k a rendezendő tömbünk első elemét, s ezt tekintsük k egy 1 elemű tömbnek, ez önmagában biztos, hogy rendezett. Ehhez hozzávessz vesszük k a 2. elemet, majd rendezzük őket. Veszzük k a 3. elemet, s ezt is rendezzük. Az eljárást ezután n addig folytatjuk, míg m g az eredeti nagy tömbünk rendezett nem lesz. Amikor a már m r rendezett résztr sztömbhöz hozzávesz veszünk egy új j elemet, akkor itt lineáris, vagy bináris keresést st végzv gzünk. 43

Tárgyszerkezetek Gyakorlat A keresés s eredmények nyeként nt megkapjuk az új elem helyét t a tömbben. t Az elem elhelyezését t beszúrással ssal végezzv gezzük, melyet úgy végzv gzünk el, hogy a már m r rendezett tömbrészletben a beszúrand randó helytől jobbra (növekv vekvő rendezésn snél) eső tömbelemeket eggyel jobbra toljuk, s az így keletkező üres helyre bemásoljuk az új j elemet. Megvalósítására láthatunk l példp ldát t lineáris és s bináris kereséssel ssel is! 44

Gyakorlat Tárgyszerkezetek int beszurlinearis() { int atmeneti, i, j, h; for(j=1;j<tombmeret;j++) { i=0; while((i<j)&&(tarolo[i]<tarolo[j])) i++; h=j; atmeneti=tarolo[h]; while(i<h) { tarolo[h]=tarolo[h-1]; h--h --;; } tarolo[h]=atmeneti; }return 0; 45

Gyakorlat Tárgyszerkezetek int beszurbinaris() { int atmeneti, j, h, also, felso, kozepso; for(j=1;j<tombmeret;j++) { also=0; felso=j; kozepso=0; while(also<felso+1) { kozepso=(also+felso)/2; if(tarolo[j]>=tarolo[kozepso]) also=kozepso-1; else felso=kozepso-1; } h=j; atmeneti=tarolo[h]; while(also<h) { tarolo[h]=tarolo[h-1]; h--h --; } tarolo[h]=atmeneti; } return 0; } 46

Gyakorlat Tárgyszerkezetek A buborékrendez krendezés lényege: a tömb t elejéről a vége v felé haladva a szomszédos elemeket hasonlítjuk össze, s amennyiben a tömb t elejéhez közelebb k lévől elem a nagyobb, akkor a két k t elemet felcserélj ljük (szokás s elemcserés s rendezésnek is nevezni). Ha elérj rjük k a tömb t végét, v akkor a legnagyobb elem a tömb t végére v kerül (felszáll), ll), így a rendezendő tömb hossza eggyel megrövid vidül. Erre a tömbre t újra alkalmazzuk az eljárást. A rendezés addig tart, amíg g a tömbmt mbméret 1 nem lesz. 47

Gyakorlat Tárgyszerkezetek int buborek() { int atmeneti, j, i; for(j=tombmeret-2;j>=0;j 2;j>=0;j--) for(i=0;i<=j;i++) if(tarolo[i+1]<tarolo[i]) /*csere*/ { /*kell*/ atmeneti=tarolo[i]; tarolo[i]=tarolo[i+1]; tarolo[i+1]=atmeneti; } return 0; } 48

Gyakorlat Tárgyszerkezetek A megismert rendezési eljárásokon kívülk léteznek még m g további, jóval j bonyolultabb eljárások is, melyek gyakorlati megvalósítása sa nem feladatunk, mégis m megemlítem őket. Ilyenek: Shell- rendezés s (Donald Shell 1959), gyorsrendezés s (Quicksort: C. A. R. Hoare 1962), rendezés s fastruktúrával, ládarendezés, és s az összefésüléses ses rendezés. A Shell módszer m lényege l az, hogy egymást stól l távolabb t álló elemeket hasonlít össze, így azok hamarabb 49

Gyakorlat Tárgyszerkezetek A gyorsrendezés s a csere elvén n alapszik, elve a következk vetkező: : kiválasztjuk a tömb t középsk pső elemét t, majd balról l megkeressük k azt az első elemet, amely ennél l nem kisebb, jobbról l pedig azt az elemet, amely ennél nem nagyobb. Kicserélj ljük k a két k t elemet, és folytatjuk a cserélget lgetést addig, amíg g a bal oldalon a középsk pső elemnél l nem nagyobb, jobb oldalon pedig mind kisebb elemek állnak. Ezt követk vetően en rekurzív v hívással h rendezzük k a tömb t alsó és s felső felét, s így tovább. 50

Tárgyszerkezetek Gyakorlat A gyorsrendezést st a legtöbb magas szintű programozási nyelv beépített módon m tartalmazza, s így könnyen k felhasználhat lható.. A másik m három h eljárást speciális esetekben szokták k alkalmazni. Pl. a ládarendezl darendezést akkor használjuk, ha az elemek értékkészlete kicsi, az összefésülésest sest pedig akkor, ha rendelkezésre áll két k t rendezett tömbt mbünk, s belőlük k szeretnénk nk egy rendezett harmadikat készk szíteni. 51

Elmélet I. Homog Tárgyszerkezetek Homogén n adatszerkezetek 2. Asszociatív v adatszerkezetek a TÁBLÁZAT,, mely tekinthető az 1 dimenziós s tömb t általánosításának. nak. A táblt blázat elemei összetettek: van egy kulcs-,, ill. egy adatrész szük. A 2 rész r típusának nem kell megegyeznie. A kulcsért rtékeknek mindig egyedieknek kell lenniük. Az adatért rtékek viszont tetszőlegesek lehetnek. Alkalmazhatunk rájuk folytonos, ill. szétsz tszórt ábrázolást (láncolt listát) t) is. Dinamikusak! 52

Tárgyszerkezetek Elmélet Hogyan hajthatók k végre v ezen az adatszerkezeten a tanult műveletek? m 1. Létrehozás: a táblt blázat szerkezetének kialakítását t jelenti. 2. Bővítés: szerkezet függf ggő a megvalósítása, sa, soros táblt blázat esetén n az időben folytonosan történik, az új j elem a táblt blázat végére v kerül. 3. Törlés: a logikai változata v esetén n az utolsó elemmel felülírjuk az előzőt, fizikai törlés, ha sok van a táblt blázatban, akkor az adatszerkezetet újra kell szervezni. 53

Tárgyszerkezetek 4. Csere: csak adatelemekre hajtható végre, kulcsot nem cserélünk. 5. Rendezés: nincs. 6. Keresés: s: teljes. 7. Elérés: szekvenciális. 8. Feldolgozás: alapja a kulcs. Speciális változatai: v Önátrendező táblázat, melyben az éppen feldolgozott elemet utolsó műveletként a táblázat elejére helyezzük. Ez a táblt blázat már r csak szétsz tszórtan ábrázolható! 54

Elmélet Tárgyszerkezetek Speciális változatai: v Rendezett táblt blázat főf jellegzetessége, ge, hogy a kulcsok szerint rendezetten tárolja t az elemeit. Feldolgozásának az alapja a rendezettség, s az ezen alapuló lineáris keresés! s! Kulcstranszformáci ciós s táblt blázat főf jellegzetessége, ge, hogy benne megvalósíthat tható a közvetlen k elérés s is. Ebben a táblt blázatban az elemek sorrendjét egy ún. Hash (hasító) ) függvf ggvény határozza meg, mely a kulcsokat a rendelkezésre álló tárhelyekre képezi k le. 55

Tárgyszerkezetek Elmélet I. Homogén n adatszerkezetek 3. Szekvenciális (,vagy lineáris) adatszerkezetek melyek közös k jellemzője, je, hogy az adatelemeik között k jól l definiált viszony áll fenn. Az adott elem pontosan 2 db másik m elemmel áll kapcsolatban, a kivételes tulajdonságú elemektől l eltekintve. Minden ilyen adatszerkezet dinamikus felépítésű! Melyek ezek az adatszerkezetek? LISTA, VEREM, SOR, és SZTRING 56

Tárgyszerkezetek Lista olyan adatszerkezet, amelyben egy elemnek pontosan egy rákövetkezr vetkezője van, kivéve ve az utolsó adatelemet és pontosan egy megelőzője van, kivéve ve az elsőt. Ezen az adatszerkezeten speciális jelöléseket és s műveleteket m értelmezünk: Lista jele: q=[x 1,x 2,,x,x n ] (üres( lista: []); Lista feje: head =x 1 ; Lista farka: toid =[x 2,,x,x n ]; Elmélet 57

Elmélet Tárgyszerkezetek Speciális jelölések és s műveletek: m Lista vége: v End =x n ; Lista mérete: m Size n= q ; Hozzáférés: Access q[i]=x i, ha i Є[1,n] -nek, akkor az üres listát értük k el; Allista képzk pzése: q[i..j]=[x i,,x,x j ], vagy q[..3]=[x 1,x 2,x 3 ]; Listák összefűzése: se: Concatenation legyen r=[y j,,y,y m ], akkor q&r=[x i,...,x n,y j,,y,y m ] 58

Tárgyszerkezetek Elmélet Hogyan hajthatók k végre v ezen az adatszerkezeten a tanult műveletek? m 1. Létrehozás: az elemek felsorolását t jelenti. 2. Bővítés: bárhol b megtehető a listában. q =q[..k]&[e]&q[k+1..] 3. Törlés: csak a fizikai törlt rlés s lehetséges, ez viszont bárhol b a listában. q =q[..k-1]&q[k+1..] 4. Csere: összefűzéssel ssel ez is megvalósíthat tható. q =q[..k-1]&[e]&q[k+1..] 59

Elmélet Tárgyszerkezetek 5. Rendezés: értelmezhető.. Folytonos ábrázolás s esetén n bármelyik b algoritmus használhat lható,, szétsz tszórtnál l viszont csak a beszúrásos sos rendezés s megengedett. 6. Keresés: s: folytonos ábrázolásnál l a teljes és s a bináris, szétsz tszórtnál l a lineáris alkalmazható. 7. Elérés: erre a műveletre m vezettük k be az Access funkciót, mely közvetlen k elérést tesz lehetővé. 8. Feldolgozás: az előzőkön n műveletekenm alapul. 60

Elmélet Tárgyszerkezetek Listák ábrázolása: mint az előzőekben ekben látható volt, megtehető folytonosan és szétsz tszórtan is! Mindkét ábrázolási módja fontos az adatszerkezetnek. Ha szétsz tszórtan ábrázoljuk, akkor általában kétirányú,, vagy láncolt l listát használunk! Igen fontosak a programozásban a lista fejénél és s végénél v l elvégezhet gezhető műveletek, most ezekkel fogunk részletesebben foglalkozni! 61

Tárgyszerkezetek Elmélet Melyek ezek? 1. Fej elérése: Access Head q[1]; 2. Bővítés s a lista fejénél: Push [x]&q; 3. Fej törlt rlése (elhagyása): Pop q[2..]; 4. Vég g elérése: Access End q[ q ]; 5. Bővítés s a végére: v Inject q&[x]; 6. Törlés s a végén: v Eject q[.. q -1]. Ezen műveletek m segíts tségével lehet speciális listákat létrehozni! l 62

Gyakorlat Tárgyszerkezetek Miért van szüks kség g a dinamikus adatszerkezetek használat latára? Nézzünk egy példp ldát! Írjunk programot, amely egy Henger nevű struktúrában tárolt t sugár, magasság és s a térfogat t adatokat kétirk tirányú listába fűzi! f FüggvF ggvények olvassák k be az adatokat, készk szítik el a láncot, l és s elvégzik a szüks kséges műveleteket m (beszúrás, s, törlt rlés, kiírás). A létrehozandl trehozandó adatstruktúránk nemcsak lista, hanem faszerkezet kialakítását is lehetővé teszi. Magát t a struktúrát t egy fejléc fájlban tároljuk, t melyet a különfk nféle függvényeinkben használunk fel. 63

Gyakorlat Tárgyszerkezetek #include <stdio.h> #include <stdlib.h> #include <math.h> #define PI 3.141592654 typedef struct hr { int sugar; int magassag; double terfogat; /* önhivatkozás s típusnt pusnévvel */ struct hr *kov, *elozo; } Henger; /* elődeklar deklarációk k következnek k */ 64

Tárgyszerkezetek Henger* Olvas(Henger **u); void KiirElore(Henger* e); void KiirHatra(Henger* u); void BeszurV(Henger **e, Henger **v, int r, int h); Henger* Torol(Henger *e, Henger **u, int x1, int y1); /* prototípusok pusok */ /* LISTAFG.H */ Gyakorlat A többi t függvf ggvényt a Dev-C++ fejlesztői környezet segíts tségével fogom bemutatni! 65

Tárgyszerkezetek Gyakorlat A Listafg.cpp állománynak az alábbi függvf ggvényeket kell tartalmaznia: Olvas() függvény értékként visszaadja a lánc l elejére, ill. egy paraméteren keresztül l a lánc l végére mutató pointert. Beolvassa az adatok darabszámát, dinamikusan létrehozza l a lánc l elemeit a malloc() függvf ggvénnyel, majd kiszámítja a térfogatot, t ill. láncba l fűzi f az elemeket. KiirElore() függvény a paraméterben kapja a lánc első elemére mutató pointert. KiirHatra() függvény a paraméterlist terlistán n kapja a lánc utolsó elemére mutató pointert. 66

Gyakorlat Tárgyszerkezetek A Listafg.cpp állománynak az alábbi függvf ggvényeket kell tartalmaznia: BeszurV() függvény paraméterlist terlistán n kapja a lánc l első elemére mutató pointert és s a beszúrand randó (sugar, magassag) adatokat. A függvf ggvény a lánc l végére szúrja be az új j listaelemet és s kiszámítja a henger térfogatt rfogatát. t. Visszatérési si értékként a lánc l elejére és s végére v mutató pointerek megváltozott értékét t szolgáltatja. ltatja. Torol() függvény a paraméterlist terlistán n kapja a lánc l elso és utolso elemére mutató pointert, valamint a törölni t kívánt k henger adatait. Az utolso mutató megváltozott értékét t pointerben (**utolso( **utolso)) adja. 67

Tárgyszerkezetek A lista strázsaelemeinek inicializálása. Helyfoglalás a struktúra számára. A henger adatainak beolvasása és a térfogatának kiszámítása: Gyakorlat R 2 *PI*magasság képlet alapján. Strázsaelemek újbóli beállítása. 68

Tárgyszerkezetek Gyakorlat Itt a visszamutató pointert kell az előző elemre állítani a láncon való végiglépkedés érdekében! A while ciklus figyeli a lánc végét, amelyet a NULL értékű mutató jelez. Tovább kell lépnünk a következőre különben végtelen ciklust kapunk! 69

Tárgyszerkezetek Paraméterei a következők: a lánc első és utolsó elemére mutató pointerek, valamint a beszúrandó sugár és magassá adatok. Gyakorlat Az eljárás eredményeként megváltoznak a lánc elejére és a végére mutató pointerek értékei. 70

Tárgyszerkezetek Paraméterek: a szokott mutatók és a henger adatai. Az utolso mutató új értékét pointerben kell megadni. Gyakorlat Visszaadott értéke: pointer. 71

Tárgyszerkezetek A main() függvény bemutatja a Henger struktúrából felépített lánc módosítását, új elem beszúrását, listázását, és törlését. Gyakorlat 72

Tárgyszerkezetek Videó! Gyakorlat 73

Tárgyszerkezetek Gyakorlat Miért van szüks kség g a dinamikus adatszerkezetek használat latára? Nézzünk egy példp ldát! T.f.,., hogy áruházi eladások adatait kell tárolnunk. t Az eladásokat egy vetel nevű struktúra ra reprezentálja, egy-egy int típusú mezővel az árukódnak, ill. az eladott darabszámnak a jelölésére, tovább bbá létezik egy char c[1000] tömb, valamiféle le termékinform kinformáció tárolására. ra. Ha azt tudjuk, hogy 1000-nél l több t adat biztosan nem jön, j akkor: struct vetel v[1000] lesz a struktúránk! Ha azonban csak néhány n ny vásárlv rlási adatunk van, akkor óriási pazarlást végeztv geztünk! 74

Gyakorlat Tárgyszerkezetek E probléma megoldására alkalmazhatunk pl. kétirányban láncolt listát. t. A lista elején és végén úgynevezett strázsaelemmel. Az előzőekben ekben leírt feladatot egyszerűsítj tjük és a vetel struktúrában csak az arukod és s az eladottdb mezőket szerepeltetjük! A láncolt l lista alapja az, hogy a struktúráinkat kiegész szítjük k 2 mutatóval, melyek típusa t struct vetel*.. Az egyik a tárolt roló listában az elemet megelőzőre (struct vetel *elozo),, a másik az őt t követk vetőre (struct vetel *kovetkezo) mutat. Az elemek így összefűzve zve láncot l alkotnak! 75

Gyakorlat Tárgyszerkezetek A lista kezdetben üres, csak a határokat jelző 2 strázsaelem van benne. Új j elem beszúrása sa úgy törtt rténik, hogy elindulunk a lista 1. elemétől, l, és s a mutatók k mentén n addig lépkedünk a listában, amíg g a beszúrand randó elem helyét t meg nem találjuk. ljuk. Mivel a listát növekvő elemsorrenddel építjük k fel, ezért az új j elemet azon két k t elem közék kell beszúrni, ahol az 1. 1. elem kulcsa még m kisebb, mint a beszúrand randóé,, de a 2. 2. elemé már r nagyobb! A beszúrás s maga egyszerű mutató átállítás s lesz: az 1. 1. kovetkezo és s a 2. 2. elozo mutatóját t az új j elemre állítjuk! 76

Tárgyszerkezetek Gyakorlat Már r csak az új j elem mutatóit kell beáll llítanunk: az elozo mutasson az 1. 1. elemre a kovetkezo a 2. 2. elemre! Kész K a beláncol ncolás! Ha minden elem kulcsa kisebb, mint a beszúrand randóé (,vagy még m g nincs is elem a listában), akkor a lépkedl pkedés s során n a listavéget jelentő strázsaelemig jutunk. Ekkor ezen elem elé kell beszúrnunk, ugyanazzal az algoritmussal, mint amit az előbb használtunk. Implementálása C-ben C a következk vetkező: 77

Gyakorlat Tárgyszerkezetek #include <stdio.h> struct vetel { int arukod; /* ez a kulcsmező */ int eladottdb; struct vetel *kovetkezo; struct vetel *elozo; }; struct vetel *kezdo; struct vetel *veg; /* strázsaelemek */ struct vetel *aktualis; struct vetel *uj; struct vetel *keres(int); 78

Tárgyszerkezetek Gyakorlat void beszur(struct vetel *v); void listaz(); void torol(int kod); int main() { /* elődeklar deklaráció */ kezdo=(struct vetel *)malloc(sizeof(struct vetel)); veg=(struct vetel *)malloc(sizeof(struct vetel)); kezdo->kovetkezo=veg; veg->elozo=kezdo; /* strázs zsák k inicializálása */ uj=(struct vetel *)malloc(sizeof(struct vetel)); uj->arukod=2; uj->eladottdb=1; 79

Tárgyszerkezetek Gyakorlat beszur(uj); uj=(struct vetel *)malloc(sizeof(struct vetel)); uj->arukod=1; beszur(uj); listaz(); uj->eladottdb=1; printf( \nt ntörlés s után\n ); torol(1); listaz(); return 0; } /* main vége v */ 80

Elmélet Tárgyszerkezetek Verem LIFO adatszerkezet 2 művelet m értelmezett rajta: az adott elem utáni bevitel és s a kivétel, vagyis a PUSH és s a POP a fejnél Hogyan hajthatók k végre v ezen az adatszerkezeten a tanult műveletek? m 1. Létrehozás: az üres verem elkész szítése. se. 2. Bővítés: csak a meglévő elemek után történhet, vagyis a verem tetején. 3. Törlés: csak a legutolsó elemet lehet fizikailag törölni, t mely az 1. sorszámú. 81

Tárgyszerkezetek Elmélet 4. Csere: nincs. 5. Rendezés: nincs. 6. Keresés: s: nincs. 7. Elérés: nincs. 8. Feldolgozás: csak a legutolsó elemre vonatkozhat, mely a verem feje. Szétsz tszórt módon m ábrázolható,, egyirány nyú listával. Létezik L egy ún. vektorreprezentáci ciója is, mely a veremmutatóra ra épül. 82

Elmélet Tárgyszerkezetek Jellemzőjük, hogy speciális fogalmakat értelmezhetünk rájuk: r Üres és s Tele. A széls lsőséges elemek implementáci ciója nehéz. Elsősorban sorban arra való,, hogy a segíts tségével megfordíthatunk egy a keletkezéskor meglévő elemsorrendet! Semmilyen program, ill. operáci ciós rendszer nem létezik l verem nélkn lkül. l. A futó programok, ill. folyamatok közötti k váltást mindig a veremmemória ria (stack memory) segíts tségével valósítjuk meg. 83

Elmélet Tárgyszerkezetek Sor FIFO adatszerkezet 4 művelet m értelmezett rajta: a fej elérése (Access Head), a fej elhagyása (POP), beszúrás s a végére v (Inject), és s a vég g elérése (Access End). Sor esetén n e műveleteknek m speciális nevük k van: PUT (olvasás s elölr lről, l, majd pedig törlt rlés), GET (írás( s a végén). v Hogyan hajthatók k végre v ezen az adatszerkezeten a tanult műveletek? m 1. Létrehozás: üres sor létrehozl trehozása. 84

Elmélet Tárgyszerkezetek 2. Bővítés: csak a sor végén v n lehetséges. 3. Törlés: csak a sor elején n lehetséges és csak fizikailag. 4. Csere: nincs. 5. Rendezés: nincs. 6. Keresés: s: nincs. 7. Elérés: nincs. 8. Feldolgozás: csak a legelső elemre vonatkozhat, mely a sor feje. Ábrázolása törtt rténhet folyamatosan és szétsz tszórtan is. 85

Tárgyszerkezetek Szétsz tszórt ábrázolásnál: két k t fejjel ellátott egy irányban láncolt l listát t használunk. Folytonos ábrázolásnál: általában vektor reprezentáci ciót t alkalmazunk. Speciális sorok: Fix kezdetű sor: az elején n van az 1-es 1 indexű,, s 1 mutatója van, a vége. v Vándorló sor: 2 mutatója van, az eleje és s a vége. v Elmélet 86

Elmélet Speciális sorok: Tárgyszerkezetek Ciklikus sor: jellemzője, je, hogy nincs benne elemmozgatás, csak írás és olvasás. s. Kettős, vagy 2 végűv sor: benne mind a 6 speciális művelet m realizálhat lható. Vagyis mindkét t végéről v l lehet írni és olvasni is (GET, PUT, RGET, RPUT), 2 összefordított veremhez hasonlíthat tható.. (Által( ltalában ilyen a memóriakezel riakezelés.) 87

Speciális sorok: Tárgyszerkezetek Prioritásos sor: e sorban az adatelemeknek van egy speciális jellemzője, je, a prioritás, mely meghatározza az írási és s a feldolgozási sorrendet. A sorokat, mint adatszerkezeteket mindenfajta pufferelésn snél l használjuk! Elmélet 88

Tárgyszerkezetek Elmélet Sztring olyan speciális lista, melynek specialitása sa az, hogy az elemei az abc szimbólumai. (Olyan sztringekkel foglalkozunk, melyek elemei karakterek.) Hogyan hajthatók k végre v ezen az adatszerkezeten a tanult műveletek? m 1. Létrehozás: feltölt ltéssel törtt rténik. 2. Bővítés: csak részsztringekre r vonatkozik ez a művelet. m 89

Tárgyszerkezetek Elmélet 3. Törlés: bármelyik b részsztringet r törölhetjük, de csak fizikailag. 4. Csere: szintén n csak részsztringre r vonatkozik. 5. Rendezés: nincs. 6. Elérés: a sztring bármelyik b karaktere elérhet rhető. 7. Keresés: s: csak részsztringre r értelmezzük. 8. Feldolgozás: alapja a részsztringre r vonatkozó keresés. s. 90

Elmélet Ábrázolása törtt Tárgyszerkezetek rténhet folytonosan és szétsz tszórtan is, de az utóbbit ritkán használjuk. A folytonos ábrázolást használva a következő reprezentáci ciók lehetségesek: 1. Minden karakternek azonos méretm retű tárhelyet foglalunk le. (pl.: 1 karakter = 1 byte) 2. Minden sztringnek annyit foglalunk le, amennyi a karakterszámb mból l adódik. dik. 91

Tárgyszerkezetek Elmélet 2. Ilyenkor a lefoglalt tárhely t elején n (1, vagy 2 bájton) b jelezzük k a sztring hosszát. Vagy esetleg a sztirng végén v n helyezünk el egy plusz bájtot, b mely a sztring végét v jelzi. Vagy lefoglalunk annyi bájtot, b amennyi a karaktereknek szüks kséges, s egy külön k n táblt blázatban tároljuk t azt az informáci ciót, hogy hol kezdődik dik a sztring. (A Pascal a 2., a C a 3. variáci ciót használja.) A sztring adatszerkezet alapproblémája a Keresés s kérdk rdése. 92

Tárgyszerkezetek A keresés, s, mint a legtöbb adatmanipuláci ciós s művelet m a sztringek esetében részsztringekre r vonatkozik. Elmélet Ezt a problémát t az ún. Mintaillesztéssel ssel oldhatjuk meg. Lényege, L hogy adva van egy alapsztring, melyet jelölj ljünk a-val, és s egy mintasztring, melyet jelölj ljünk b-vel. Meg kell határoznunk azt, hogy a mintasztring előfordul fordul-e, s ha igen, akkor hányszor h az alapsztringben. 93

Elmélet Tárgyszerkezetek Milyen algoritmusok képesek k e műveletet m hatékonny konnyá tenni? Több megoldás s is létezik: l 1. Mezitlábas algoritmus lényege a mintasztringgel törtt rténő elemenkénti nti összehasonlítás, s, a képfeldolgozk pfeldolgozásban alkalmazzák. k. 2. KMP algoritmus mely kihasználja a mintasztringnek az önmagára való illesztését. t. 3. Dömölki-féle le algoritmus nincs benne semmilyen visszalépés s (bitmátrix). trix). 94

Tárgyszerkezetek Elmélet I. Homogén n adatszerkezetek 4. Hierarchikus minden elemének egy megelőzője és s akárh rhány rákövetkezr vetkezője lehet. A legfontosabb konkrét t ilyen adatszerkezet a Fa,, ez matematikailag egy speciális gráf. Fa adatszerkezet: van egy kitüntetett eleme, ez a gyökérelem relem,, melynek nincs megelőzője. Akárh rhány olyan eleme lehet, melynek nincs rákövetkezője, ezek a levélelemek lelemek. 95

Tárgyszerkezetek Elmélet A fában f a gyökért rtől l a levélig lig egy adott sorozaton keresztül l juthatunk el. Ezt a bejárást útnak nevezzük. Dinamikus adatszerkezet. A fa szintjeinek magasságát,, a fa magasságának nevezzük. A fa bármely b eleme lehet egy részfa gyökéreleme. A fákkal f végezhetv gezhető műveletek általában részfr szfákra vonatkoznak. Rendezettnek nevezzük k a fát, ha a rákövetkezr vetkezőinek a sorrendje meghatározott. 96

Tárgyszerkezetek Elmélet Azt a fát, f ahol minden elemnek 2 db rákövetkezője lehet, bináris fának f nevezzük. Rendezett bináris fáknf knál beszélhet lhetünk bal-,, ill. jobb oldali rákövetkezőről. Ennek az adatszerkezetnek alapvető szerepe van az informatikában. Bármilyen B nem bináris fa reprezentálhat lható egy megfelelő módon előáll llított bináris fával. f A leképez pezés s a következk vetkező: 97

Tárgyszerkezetek a a e b c f d g h e b f c d A leképezés algoritmusa: Az egy szinten lévő elemek az eredeti fában, a jobboldali rákövetkezők lesznek az új bináris fában. g h Elmélet 98

Elmélet Tárgyszerkezetek Hogyan hajthatók k végre v ezen az adatszerkezeten a tanult műveletek? m 1. Létrehozás: létrehozzuk l a gyökérelemet, majd pedig bővítünk. b 2. Bővítés: általában a levélelemekn lelemeknél történik, valamekkora méretm retű részfával. 3. Törlés: általában részfr szfát t törlt rlünk fizikailag, logikai törlt rlés s nincs. 4. Csere: bármely b elem könnyen k felülírhat rható. 5. Rendezés, Keresés és s Elérés: helyett... 8. Feldolgozás: alapja a bejárás. 99

Tárgyszerkezetek Gyakorlat Bináris fák f k bejárása 3 féle f módon m történhet: Preorder, Inorder és Posztorder módon. m 1. Preorder bejárás: Ha üres a fa, akkor vége. v Ha nem üres, akkor megfogjuk a gyökérelemet, majd preorder módon m (a legbaloldalibb megfogásával) bejárjuk a baloldali részfr szfát, majd preorder módon m bejárjuk a jobboldali részfr szfát. Ezen a módon m kapjuk egy matematikai kifejezés s prefix alakját! 2. Inorder bejárás: Ha üres Inorder módon m bejárjuk a baloldalt, megfogjuk a gyökérelemet, majd inorder módon m a jobboldali részfr szfát. Így állítjuk elő a matematikai kifejezés s infix alakját. 100

Tárgyszerkezetek a / + * b c - d e Prefix kifejezés: +/ab*c-de Infix kifejezés: a/b+c*d-e Posztfix kifejezés: ab/cde-*+ Gyakorlat 3. Posztorder bejárás: Ha üres Posztorder módon bejárjuk a baloldali részfát, majd a jobboldalit, végül megfogjuk a gyökérelemet. Ekkor keletkezik a posztfix alak, melyet szokás fordított lengyel formának is nevezni! 101

Tárgyszerkezetek Gyakorlat A prefix és s a posztfix alakja egy kifejezésnek kölcsk lcsönösen sen egyértelm rtelműen en megfeleltethető egy bináris fának, f de az infix alakja nem. Ekkor annyi darab különbk nböző fánk lehet, ahány operátora van a kifejezésnek. Ezt az ellentmondást a zárójelezéssel oldhatjuk fel! Vagyis: Speciális fák: f ((a/b)+(c*(d-e))) 102

Elmélet 1. Minim Tárgyszerkezetek Minimális magasságú fa olyan fa, mely egy adott elemszám m mellett a lehető legkevesebb szintet tartalmazza. 2. Tökéletesen kiegyensúlyozott fa benne minden elemre igaz, hogy az adott elem bal- és s jobboldali részfr szfájában az elemek száma legfeljebb eggyel tér t el egymást stól. 3. Kereső fa az adatelemei olyanok, hogy van kulcsuk, s így értelmezhető rajtuk a keresés s művelete. m 103

Elmélet 4. Felf Tárgyszerkezetek Felfűzött fa a preorder és s az inorder bejárást segítő fa. 5. B-fa a többt bbágú fa egy speciális változata, a kereső fa általánosítása. sa. Tökéletesen kiegyensúlyozott lapokból áll! Egy lapon több t elem helyezhető el, a levéllapok llapok mind egy szinten vannak. Minden ilyen fának f rendje (n) van. Minden lapon maximum 2n db elem helyezhető el. A gyökérlapon legalább 1 db, a többi t lapon legalább n db elem. 104

Keresés a 2-rendű B-fában A lapokra szintenként lefelé haladva maximum 2 n db elem kerülhet! 25 10 21 30 40 2,5,7,8 13,14,15,18 22,24 26,27,28 32,35,38 41,44,45,46 Ha a B-fát szintenként összenyomjuk, akkor egy növekvő kulcssorrendű sorozatot kapunk. A B-fának az állománykezelésben van szerepe, ahol ennek az adatszerkezetnek egy változatát használják. Elmélet Vizsgáljuk meg erre az adatszerkezetre a tanult műveleteket! 105

Elmélet Tárgyszerkezetek 1. Létrehozás: létrehozzuk l a gyökérelemet, majd pedig bővítünk. b 2. Bővítés: elősz ször r megkeressük k a bővítőb elem helyét t a fában, f mely csak levéllapon llapon lehet. Pl. az előző fa esetén n legyen ez most 23! Ekkor, ha az adott lapon 2n-nél l kevesebb elem van, akkor a rendezettséget megtartva elhelyezzük. Ha pont 2n elem van a lapon, akkor lapfelezés következik be. Ilyenkor az új j elem elhelyezése után n kiválasztjuk az elemek közül k l a középsk psőt, melyet az egy szinttel felette lévől lapra helyezünk, s az eredeti lapon maradt 2n db elemet ketté osztjuk (megfelezzük). 106

Tárgyszerkezetek Elmélet 2. Bővítés: a lapfelezés s során n 1 db új j levéllap llap keletkezik. Előfordulhat az is, hogy a lapfelezés s végiggyv giggyűrűzik a fán, f s ekkor nőn a fa magassága. ga. 3. Törlés: mindig fizikai és s bármelyik b elem törölhető.. Hasonló módszerrel törtt rténik, mint a bővítés. Ha a levéllapon llapon van a törlendt rlendő elem, akkor a megkeresése se után n törölhett lhető.. Ha nem levéllapon llapon van, akkor felülírjuk őt t egy ott maradó elemmel, majd pedig töröljt ljük. Ha a törlendő elemet tartalmazó lapon csak n db elem találhat lható,, akkor egy azonos szinten találhat lható (ún. testvérlapr rlapról) l) hozunk át t elemet. 107

Tárgyszerkezetek 3. Törlés: ha nincs lehetőség g a testvérlapr rlapról l elem áthozatalára, akkor lapösszevon sszevonást st kell elvégezn geznünk. nk. A lapösszevon sszevonás s végiggv giggöröghet ghet a fán, s ilyenkor csökken a fa magassága. ga. 4. Csere: nem értelmezett. 5. Rendezés: a lapok a kulcs szerint rendezettek. 6. Keresés: s: kulcs szerinti lineáris a lapokon belül. l. 7. Elérés: bejárással törtt rténik. 8. Feldolgozás: A B-fát B t mindig a memóri riában építjük k fel, s ilyenkor az alapja az ismertetett keresés s lesz. Elmélet 108

Tárgyszerkezetek Elmélet Fák ábrázolása: : lehetséges folytonosan és szétsz tszórtan is. Ha folytonosan törtt rténik, akkor 1 dimenziós s tömbt mböt t alkalmazunk rá,, használata a statikusság g miatt nem célszerű. Általában a szétsz tszórt ábrázolást használjuk, kétirk tirányú lista felhasználásával. A bejárás s művelet m elvégz gzése során n a fát f t sorra képezzk pezzük k le. E művelet m értelmezhető többágú fákra is, amikor preorder módon m bejárjuk a legbaloldalibb részfr szfát, majd a többit t is! 109

Tárgyszerkezetek Gyakorlat Miért van szüks kség g a dinamikus adatszerkezetek használat latára? Nézzünk egy példp ldát! T.f., hogy áruházi eladások adatait kell tárolnunk. t Az eladásokat egy vetel nevű struktúra ra reprezentálja, egy-egy int típusú mezővel az árukódnak, ill. az eladott darabszámnak a jelölésére, tovább bbá létezik egy char c[1000] tömb, valamiféle le termékinform kinformáció tárolására. ra. Ha azt tudjuk, hogy 1000-nél l több t adat biztosan nem jön, j akkor: struct vetel v[1000] lesz a struktúránk! Ha azonban csak néhány n ny vásárlv rlási adatunk van, akkor óriási pazarlást végeztv geztünk! 110

Gyakorlat Tárgyszerkezetek E probléma megoldására alkalmazhatunk pl. kétirányban láncolt l listát, t, vagy bináris keresőfát.. A lista elején és s végén v úgynevezett strázsaelemmel. Az előzőekben ekben leírt feladatot egyszerűsítj tjük és a vetel struktúrában csak az arukod és s az eladottdb mezőket szerepeltetjük! A tárolandt rolandó elemeket a bináris fában f is mutatók kötik össze, mint a listában. Minden csomóponthoz legfeljebb 2 másik m csomópont tartozik, ezek lesznek a csomópont gyermekei. A gyermekekre a bal és s a jobb mutatók k fognak mutatni! 111

Bináris keresőfa 11 51 5 1 19 1 NULL Gyakorlat NULL 3 4 NULL NULL 13 51 NULL NULL 21 2 NULL 112

Bináris keresőfa programja Struktúra létrehozása: #include <stdio.h> #include <stdlib.h> Gyakorlat struct vetel { int arukod; /* ez a kulcs mező */ int eladottdb; struct vetel *bal; struct vetel *jobb; }; struct vetel *gyoker, *aktualis; Definiáljuk a tároló struktúrát (vetel), és létrehozunk 2 mutatót, melyek közül az 1. a gyökérelemre mutat, a másik az aktuálisra. 113

Bináris keresőfa programja Gyakorlat Beszúrás művelete: struct vetel* beepit(struct vetel *hova, struct vetel *elem) { if(hova==null) { hova=elem; hova->bal=hova->jobb=null; return hova; } else if(hova->arukod==elem->arukod) hova->eladottdb+=elem->eladottdb; else if(hova->arukod>elem->arukod) hova->bal=beepit(hova->bal,elem); else hova->jobb=beepit(hova->jobb,elem); return hova; } 114

Bináris keresőfa programja Gyakorlat Hogyan történik a beszúrás művelete? A vetel függvény paraméterül várja annak a fának a gyökérmutatóját, ahová a beszúrás történik, illetve a beszúrandó elemet. Ha a hova gyökérmutató NULL értékű, akkor a fa üres, s ezért egyszerűen az új elemre kell állítani a gyökérmutatót. Ha a gyökérelem már létezik, akkor 3 eset lehetséges: 1. a beszúrandó elem arukod nevű kulcsa megegyezik a gyökérelemével, s ekkor növelnünk kell az eladottdb változó értékét! 115

Bináris keresőfa programja Gyakorlat Hogyan történik a beszúrás művelete? Ha a gyökérelem már létezik, akkor 3 eset lehetséges: 2. a beszúrandó elem arukod nevű kulcsa kisebb a gyökérelemnél, akkor a bal oldali részfába szúrjuk be az elemet! 3. a beszúrandó elem arukod nevű kulcsa nagyobb a gyökérelemnél, akkor a jobb oldali részfába szúrjuk be az elemet! Ez utóbbi két művelet a beepit függvény rekurzív meghívását igényli. Fontos még, hogy a visszatérési érték struct vetel* típusú! 116

Bináris keresőfa programja Gyakorlat Növekvő sorrend szerinti listázás: void listaz(struct vetel *mit) { if(mit==null) return; else { listaz(mit->bal); printf( Árukód: %d, eladott menny.: %d\n,mit->arukod, mit->eladottdb); } } 117

Bináris keresőfa programja Gyakorlat Növekvő sorrend szerinti listázás: rekurzív módon történik. Ha a paraméterül kapott részfa gyökerének mutatója mit=null, akkor nincs mit kiírni, a fa üres. Egyébként kiírjuk a baloldali részfában lévő elemeket egy rekurzív listaz hívással, majd a gyökérelemet egy printf függvénnyel, s végül a jobboldali részfában lévő elemeket egy újabb rekurzív listaz hívással. A keresőfatulajdonságnak megfelelően növekvő sorrendben fogja kiírni az elemeket. A rekurziókat pedig a NULL mutató elérése fogja befejeztetni. 118

Bináris keresőfa programja Gyakorlat Keresés megvalósítása: struct vetel* keres(struct vetel *hol,int kod) { if(hol==null) return NULL; else if(hol->arukod==kod) return hol; else if(hol->arukod>kod) return keres(hol->bal,kod); else return keres(hol->jobb,kod); } 119

Bináris keresőfa programja Gyakorlat Keresés megvalósítása: szintén rekurzióval történik. A művelet hasonlóan történik a listázáshoz! A keres függvény NULL értéket ad vissza, ha a keresett elem (kod) nincs a fában, egyébként pedig az elem kod nevű mutatóját szolgáltatja eredményül. A törlés műveletének megvalósításával azért nem foglalkozunk, mert az lényegesen bonyolultabb a bemutatottaknál! Végül lássunk egy példát a bináris keresőfa alkalmazására! 120

Bináris keresőfa programja Gyakorlat Főprogram megvalósítása: int main() { int i,elemkod[10]={11,2,5,4,0,2,1,15,12,8}; gyoker=null; for(i=0;i<10;i++) { aktualis=((struct vetel *) malloc(sizeof(struct vetel)); aktualis->arukod=elemkod[i]; aktualis->eladottdb=i; 121

Bináris keresőfa programja Gyakorlat Főprogram megvalósítása: print( Elemkód %d\n, aktualis->arukod); gyoker=beepit(gyoker,aktualis); } listaz(gyoker); aktualis=keres(gyoker,12); printf( Keresett elemkód %d\n, aktualis->arukod); printf( Megtalált elemszám %d\n, aktualis->eladottdb); return 0; } 122

Elmélet Tárgyszerkezetek I. Homogén n adatszerkezetek 5. Hálós s adatszerkezetek HÁLÓ,, mely tekinthető a hierarchikus adatszerkezetek általánosításának. nak. Bármely eleme lehet az őt t megelőzője, és s a rákövetkezr vetkezője is, akár r még m önmagáé is. Nincs kitüntetett elemük és dinamikusak! Matematikailag egy irány nyított, összefüggő gráfnak tekintjük. k. A szerkezetet magával az ábrázolással definiáljuk, mely törtt rténhet az előbb említett irány nyított gráffal, vagy ún. 123

Tárgyszerkezetek Hálós s adatszerkezetek a szerkezet megadása. 1. Irány nyított gráf f segíts tségével: 1. 2. 3. a c e b d f Elmélet 4. 5. 6. 124

Tárgyszerkezetek 2. Szomszédoss dossági mátrix m segíts tségével: Elmélet 1. a b 4. 2. 3. c d 5. e f 6. Ha van n db elem ( 6 db), akkor egy n*n-es bitmátrixot hozunk létre, amelyet soronként töltünk fel. Nullát írunk oda (ahhoz az elemhez), ahol az oszlop nem rákövetkezője az adott sornak. 1 2 3 4 5 6 1 0 1 0 1 0 0 2 0 0 0 1 1 0 3 0 0 0 0 1 1 4 0 1 0 0 0 0 5 0 0 0 1 0 0 6 0 0 0 0 0 1 E mátrix mellett felépítünk egy vektort is, amely a háló elemeinek az értékeit tartalmazza. 125