Rekordok Dinamikus tárkezelés és pointerek Dinamikusan láncolt listák

Ismétlés: Rekordok

Rekordok rekordokon belül Ez az azonosító mostantól egy típus, amit bárhol felhasználhatunk, mint pl. a “word” típust. Semmi nem akadályoz meg minket abban, hogy rekordokat használjunk egy rekord mezőjeként : Type datum_tipus = record nap, honap, ev: word; end; diak_tipus = record nev: string[20]; osztaly: byte; szul_nap: datum_tipus; erettsegi_nap: datum_tipus; Minek nevezzük ezeket? Típusok

Rekordok rekordokon belül nap honap ev datum_tipus: diak_tipus: Var bob: diak_tipus; bob.szul_nap.honap := 6; nap honap ev nev osztaly szul_nap erettsegi_nap

Típusok vagy változók Típusdefiníciók (TYPE) Új típusokat hozunk létre, ha összetett adatszerkezeteket használunk, vagy teljesen új fajta adattípussal kell dolgoznunk Nem hoz létre változót – nincs tárhelyfoglalás A felhasználási köre korlátlan Változók deklarálása (VAR) Aktuálisan foglal helyet a memóriában az adatnak Korlátozott a felhasználása – csak az őt tartalmazó modul “látja” a változót (alprogram, főprogram) Egy már létező adattípussal használható

Dinamikus tárkezelés és pointerek

Dinamikus kontra statikus Statikus (rögzített méretű) Néha olyan adatszerkezeteket használunk, melyek “rögzítettek” és nincs szükségünk méretük növelésére vagy csökkentésére. Dinamikus (méretében változó) Máskor, szeretnénk növelni vagy csökkenteni az adatszerkezeteink méretét, hogy megfeleljenek a feladat követelményeinek.

Statikus adatok Statikus adatok a program futása előtt deklarálódnak. Egy adott modulban deklarálódnak (vagy a főprog-ramban) és addig “maradnak életben” amíg az illető modul aktív. Ha több statikus adatot deklarálunk, mint amire szükségünk van feleslegesen foglalunk tárhelyet . Ha kevesebb statikus változót deklarálunk a szüksé-gesnél, nem tudjuk majd megoldani a feladatot. A valós életbeli problémák megoldása során gyakran fordul elő, hogy nem tudjuk hány változót kell előre deklarálnunk, ezek száma időben változni fog.

Dinamikus adatok Dinamikus adatok időben nőnek vagy csökkennek, méretük szerint, a követelményeknek megfelelően. Bármikor szükséges létrehozhatunk dinamikus változókat és tárhelyet allokálhatunk (foglalhatunk) számukra. Bármikor szükséges felszabadíthatjuk (kill) a dinamikus változók által lefoglalt tárhelyet. A legfontosabb előnye a dinamikus adatoknak, hogy mindig pontosan annyi változóval dolgozunk, amennyire szükség van, sem többel, sem kevesebbel. Például, pointerekkel (mutatókkal) összekapcsolhatunk adatokat és dinamikus adatszerkezeteket hozhatunk létre, mint a láncolt listák vagy dinamikusan ábrázolt bináris fák.

Megjegyzés A dinamikus adatok használata sokkal nagyobb rugalmasságot biztosít. A memória még mindig véges !! Mostantól viszont mi használjuk fel, ahogyan akarjuk a memóriát. És tesszük ezt a program futása közben. Példák: Nyomtató várakozási sora Repülésirányító ....akármi más ?, adj példát

A memória szerkezete egy program esetén Kódszegmens (a program forráskódját tartalmazó modul) Verem (Statikus Rész) (felfelé foglal új helyet) Heap (Kupac) (Dinamikus Rész) (lefelé foglal új helyet)

A Heap (kupacmemória) Heap 12 Heap Főprogram egy_változó más_változó ptr 4 7 Ez milyen típusú változó??? A heap a memóriának egy része, ahol a dinamikus tárkezelés megvalósul A statikus változók az adatszegmensben vagy a veremszegmensben kapnak helyet (ezek is a memóriának részei)

A NEW() eljárás paramétere egy mutató tárhelyet foglal le a heap-ben, egy adott típusú mutatónak megfelelő méretet Var p: ^byte; ps:^string; new(p); new(ps);

Dinamikusan tárolt adat elérése pointerrel 43 Heap: dinamikus Főprogram p Adatsz.: Statikus Mikor “követünk egy mutatót”, azt mondjuk elvonatkoztatunk az illető pointertől A kalap (^) jelentése “a pointernél levő adat” p^ jelentése ”kövesd, hogy a p mire mutat” p^:=43; érvényes értékadás

Pointer Animation of Numbers Képernyőn: Var P,Q:^word; new(P); P^:= 5; Q:= P; writeln(P^, Q^); Q^ := 7; 5 5 7 7 5 5 word típus Pointer P 7 5 Pointer Q Pointer Animation of Numbers statikus dinamikus

Egy mutató (pointer) egy diak rekordhoz: Egy record, amely két adatot fog tárolni - egy nevet és egy személyi számot (CNP) : Type diak = record nev : String[20]; CNP : longint; end; Egy mutató (pointer) egy diak rekordhoz: Var pdiak : ^diak; New(pdiak); nev CNP

Pointerek és rekordok Bob pdiak 123456789 statikus dinamikus pdiak

Pointerek és rekordok Bob pdiak 123456789 statikus dinamikus pdiak^

Pointerek és rekordok pdiak pdiak^.nev := ’Bob’; Bob 123456789 statikus dinamikus pdiak^.nev := ’Bob’;

Pointerek és rekordok pdiak pdiak^.CNP := 123456789; Bob 123456789 statikus dinamikus pdiak^.CNP := 123456789;

Láncolt listák

Listák tulajdonságai Sokszor azonos típusú adatokkal kell dolgoznunk Néha csak kevés memóriára lenne szükségünk: Néha viszont sok memóriát kell használnunk: Ilyen esetekben a megszokott módon nem deklarálhatunk változókat, mert nem tudjuk előre hány változót kell deklarálnunk Más módon kell megoldanunk az adatok dinamikus (futás közbeni) helyfoglalását (allokációját) illetve a lefoglalt tárhely felszabadítását.

Láncolt listák Mutatók (pointerek) segítségével az adatokat össze tudjuk fűzni („láncolni”): Type lista = ^lista_elem; lista_elem = Record adat: word; kov: lista; End; 4 17 42 NIL

Láncolt lista egy elemének létrehozása Type lista = ^lista_elem; {mutató a lista egy eleméhez} lista_elem = Record adat: word; {itt a feladattól függően,} kov: lista; { szerepelhet több mező is} End; {a lista egy eleme} Var akt_elem: lista; new(akt_elem); {lefoglal helyet egy listaelemnek}

Mutatók és láncolt listák akt_elem ^.adat akt_elem ^.kov akt_elem statikus dinamikus akt_elem^

Egy listaelem mezőinek elérése 42 akt_elem NIL statikus dinamikus akt_elem^.adat := 42; akt_elem ^.kov := NIL;

Egy mutató deklarálása (a Heap egy címére mutat) ? Főprogram elso Var elso: lista; {egy mutató} Megjegyzés: az elso nincs inicializálva és egy ismeretlen helyre mutat (“szemét”-re).

A lista első elemének létrehozása ? Főprogram elso New(elso); {az elso-nek hely foglalódik a Heap-ben, de a mezők értékeit még be kell állítanunk}

Az adat mező feltöltése 42 ? Főprogram elso elso^.adat := 42; A ^ operátor a pointer által mutatott helyen levő adattípusra hivatkozik a heap-ben.

Egy második elem létrehozása 42 ? Főprogram elso elso^.adat := 42; new(elso^.kov); A “.” operátor a record egy mezőjét éri el.

A láncolt listát lezárjuk 42 91 NIL Főprogram elso elso^.kov^.adat := 91; elso^.kov^.kov := NIL; A lista végét a NIL-lel jelezzük.

Az első elem törlése 42 91 NIL Főprogram elso p Egy segédváItozó felhasználásával töröljük a lista első elemét (p ugyanolyan típusú, mint elso). p:=elso; elso := elso^.kov; dispose(p);

Új listaelem beszúrása a lista végére, ha a lista elejére van mutató és a lista nem üres 4 17 42 NIL elso p 20 NIL uj p := elso; while p^.kov<> NIL do p:=p^.kov; new(uj); uj^.adat:=20; uj^.kov:=NIL; p^.kov:=uj; {p a segéd, ugyanolyan típusú, mint elso} {p-t elvisszük a lista utolsó eleméhez} {uj ugyanolyan típusú, mint elso}

Új listaelem beszúrása a lista elejére, ha a lista elejére van mutató és a lista nem üres 20 4 17 42 NIL uj elso new(uj); uj^.adat:=20; uj^.kov:= elso; elso:=uj; {uj ugyanolyan típusú, mint elso}

Új listaelem beszúrása a listába, adott tulajdonságú elem után, ha a lista elejére van mutató és a lista nem üres 4 17 42 NIL 20 elso p uj {a p-vel a keresett tulajdonságú elemre állunk (a példában az első páratlan szám) } {p-t elvisszük az első páratlan elemhez, vagy ha nincs ilyen a lista végéig} {előfordulhat, hogy nem találtunk páratlan elemet, ezért megvizsgáljuk, hogy a lista végén vagyunk-e a p-vel. Ha p páratlan számnál áll, akkor beszúrunk a p után} p := elso; while (p^.adat mod 2 = 0) and (p^.kov<>NIL) do p:=p^.kov; if p^.adat mod 2 <> 0 then begin new(uj); uj^.adat:=20; uj^.kov:=p^.kov; p^.kov:=uj; end; Mi történik, ha a listában az első páratlan szám az utolsó elem? Vezesd le lapon magadnak !!!

Törlésnél érvényes szabályok Lista első elemének törlése, ha a lista elejére van mutató és a lista nem üres 4 17 42 NIL elso q Törlésnél érvényes szabályok egy segédmutatóval mindig a törlendő elemhez állunk, egy másikkal pedig a törlendő elem elé (a példában q-vel az első elemre állunk) a többi mutatót mind átkapcsoljuk felszabadítjuk a q-vel mutatott elem által elfoglalt tárhelyet q := elso; elso:=elso^.kov; dispose(q);

Adott tulajdonságú elem törlése a listából, ha a lista elejére van mutató és a lista nem üres 4 17 20 42 NIL elso p q { feltételezzük, hogy nem az első elemet kell törölni q-val a keresett tulajdonságú elemre állunk, p-vel pedig a törlendő elem elé (a példában az első 20-as szám) } {p-t elvisszük az első 20-as elem elé, vagy ha nincs ilyen a lista utolsó előtti eleméig} {előfordulhat, hogy nem találtunk 20-as elemet, ezért megvizsgáljuk, hogy a lista végén vagyunk-e a p következőjével. Ha p következője 20-as számnál áll, akkor törlünk a p után} p := elso; while (p^.kov^.adat <> 20) and (p^.kov^.kov<>NIL) do p:=p^.kov; if p^.kov^.adat = 20 then begin q:=p^.kov; p^.kov:=q^.kov; dispose(q); end; Mi történik, ha nincs a listában a 20-as érték?

Mi történik, ha nincs a listában a 20-as érték? Adott tulajdonságú elem törlése a listából, ha a lista elejére van mutató és a lista nem üres (kicsit másképp) 4 17 20 42 NIL elso p q feltételezzük, hogy nem az első elemet kell törölni q-val a keresett tulajdonságú elemre állunk, p-vel pedig a törlendő elem elé (a példában az első 20-as szám) {p-t és q-t egyszerre mozgatjuk} p := elso; q := p^.kov; while (q^.adat <> 20) and (q^.kov<>NIL) do begin p:=p^.kov; q:=q^.kov; end; if q^.adat = 20 then begin p^.kov:=q^.kov; dispose(q); Mi történik, ha nincs a listában a 20-as érték? Hát, ha a 20-as érték az utolsó a listában? Vezesd le ezeket az eseteket!!!

1. Feladat: Készítsünk duplán láncolt körlistát az alábbi elemekkel: q NIL NIL NIL NIL NIL NIL r p^.kov := q; q^.kov := r; r^.kov := p; q^.eloz :=p; r^.eloz := q; p^.eloz := r;

2. Feladat: Készítsünk duplán láncolt körlistát két duplán láncolt listából, ha csak az első elemekre van mutató kezdetben. elso1 NIL 1 2 3 4 NIL p elso2 NIL 5 6 7 NIL q p^.kov:=elso2; elso2^.eloz :=p; q^.kov := elso1; elso1^.eloz :=q; p:=elso1; while p^.kov<>NIL do p:= p^.kov; q:=elso2; while q^.kov<>NIL do q:= q^.kov;

p^.kov:=s; s^.kov:=r; r^.kov:=q; q^.eloz :=r; r^.eloz :=s; 3. Feladat: Egy duplán láncolt dinamikus listában pontosan négy elem található, a p változó az első, a q pedig az utolsó listaelem címét tárolja. Cseréljük fel a 2. és a 3. elemet a megfelelő mutatók átkapcsolásával . NIL 2 1 4 NIL r p q 3 s Segédváltozókat (r, s) vezetünk be, így könnyebb felírni a mutatók átkapcsolását. p^.kov:=s; s^.kov:=r; r^.kov:=q; q^.eloz :=r; r^.eloz :=s; s^.eloz :=p; r:=p^.kov; s:=q^.eloz;

Köszönöm a figyelmet!! Linkek http://www.prog.ide.sk/pas2.php?s=48 http://www.prog.ide.sk/pas2.php?s=50 http://www.prog.ide.sk/pas2.php?s=52 http://en.wikipedia.org/wiki/Linked_list Köszönöm a figyelmet!!