Adatszerkezetek és adattípusok. Vermek-Sorok (dinamikusan)

Átírás

1 6. Adatszerkezetek és adattípusok Vermek-Sorok (dinamikusan)

2 Fontos tudnivalók Elméleti tesztek: Első projekt témája (tétel, tömb, halmaz) Parciális (7-8-9 hét)

3 Algoritmusok és adatszerkezetek Algoritmusok elemzése Adatszerkezetek és adattípusok Statikus adatszerkezetek: Tétel (rekord), tömb Félstatikus adatszerkezetek: Vermek, sorok Dinamikus adatszerkezetek: Listák

4 Ismétlés, összefoglaló Dinamikus adatszerkezetek: Fák, Bináris keresőfák Hasítótáblák Rendezési algoritmusok Keresési algoritmusok Adattömörítés

5 13 14 Félig strukturált adatok Összefoglaló és ismétlés

6 ! Válaszaitok Ha gondot okoz a labor házi megoldása, honnan kérsz segítséget? (egy szó)

7 ? RAJTAD A SOR! Szeretnéd a parciálison használni a jegyzeted?

8 ? RAJTAD A SOR! Add meg a következő kérdésre a helyes választ (mérjed az időt!!!)

9 Ismeretek ellenőrzése - Figyelmesen olvasd el a kérdést - Csak egy helyes válasz van - 10 kérdésre kell válaszolni - A válaszok megadása időhöz kötött - Sor=várakozási sor Jó munkát!

10 Feladat-Verem Helyes zárójelezés:döntsük el, hogy egy kifejezésben használt zárójelek használata helyes-e: -a nyitó és csukó zárójelek száma megegyezik -a zárójelezés bármely pontjában a nyitó zárójelek száma nagyobb vagy egyenlő, mint a csukó zárójelek száma

11 Feladat-sor Egy bevásárlóközpont két parkolójának kivezetése ugyanarra az útra nyílik. Mindkét parkoló kijáratát rendőrlámpa szabályozza. A parkolók kivezető szakaszain a lámpa előtt autók állnak sorban. Az egyik lámpa 3 autót enged át egyszerre, a másik csak kettőt. Írj programot, mely meghatározza az elvezető úton lévő autók sorrendjét. Használj sor adatszerkezetet és a hozzá kapcsolódó műveleteket!

12 Absztrakt adattípusok (AAT) Összetett típusok Statikus adatszerkezetek Tétel (record) Tömb (array) Halmaz (set) Félstatikus adatszerkezetek Verem (stack) Várakozási sor (queue) Hasító tábla (hashing table) Dinamikus adatszerkezetek Lineáris lista (list) Fa (tree) bináris fa

13 Dinamikus adatszerkezetek a dinamikus adatszerkezetek komponenseinek száma változik a program végrehajtása során (nő vagy csökken)) elkerülhető a statikus tárkezelés hátrányai (a tárhely nem bizonyul elégségesnek vagy túl nagynak bizonyul) elkerülhető a statikus tárkezelés hátrányai ami a törlés és beszúrás időigényességét illeti (tologatás balra, jobbra)

14 Dinamikus adatszerkezetek dinamikus adatszerekezetek esetén a beszúrás és törlés az adatszerkezet láncolását teszi szükségessé a dinamikus változónak tartalmaznia kell a feldolgozandó információ mellett a láncolásra hivatkozó információt is azok a dinamikus adtaszerkezetek, amelyekben az elemek egyetlen szinten fűződnek (láncolódnak) egymás után a lineáris lista nevet viselik speciális lineáris listák: verem, várakozási sor, egyszeresen-, kétszeresen- és körkörösen láncolt lista

15 Listák

16 Lista csomópontok

17 Lista - osztályozás

18 A verem (Stack) LIFO = last in first out (dinamikus implementáció) Értelmezés: 1.Statikus Dinamikus megvalósítás esetén a verem elemeit egy tömbben tároljuk nek tárolása egy speciális listát használunk, amelyben minden beszúrási és törlési művelet csak a lista egyik végén történik. 2.A veremben lévő elemek számát, más szóval az utoljára betett elem sorszámát egy ún. veremmutató tartalmazza. A veremben utoljára betett elem címét egy ún. veremmutató pointer tartalmazza. 3. Ha új elemet teszünk a verembe, a veremmutató értéke eggyel nő, ha kiveszünk, akkor eggyel csökken. Üres verem esetén értéke 0, teli verem esetén pedig egyenlő a vektor maximális indexével. A kapcsolattartó mező annak az elemnek a címe, amelyet az előző beszúrás alkalmával helyeztünk a verembe. Ez alól csak egy elem kivétel, az alap, melynek a kapcsolatmezője NULL.

19 A verem (stack) Értékhalmaz: mystack verem sp a verem teteje (veremmutató) typedef struct { int maxsize; int sp; int *items; } STACK; STACK *mystack; Stack verem typedef struct NodeType{ int info; struct NodeType *next; }NodeType; NodeType *topptr; Érték Saját cím Következő elem címe

20 A verem (Stack) Műveletek: (O(1)) Üres?: igaz, ha a verem csúcsának mutatója NULL-e IsEmpty (topptr) if topptr=null then return true else return false!!! topptr=null (főprogramban) Inicializálás: egy új csomópont helyfoglalása, a kapcsolattartó mező értéke NULL Create () uj_elem helyfoglálása uj_elem->next=null NULL

21 A verem (stack) Verembe (push): egy elem bevitele a verembe (a verem tetejére ). létrehozunk egy új csomópontot Push (topptr, a) NodeType newnode newnode=create()!!!! int main() {NodeType *node=null; } NULL newnode 2 topptr 1

22 A verem (stack) Verembe (push): egy elem bevitele a verembe (a verem tetejére ). létrehozunk egy új csomópontot feltöltjük értékkel az info mezőt Push (topptr, a) NodeType newnode newnode=create() newnode->info=a!!!! int main() {NodeType *node=null; } newnode 3 NULL 2 topptr 1

23 A verem (stack) Verembe (push): egy elem bevitele a verembe (a verem tetejére ). létrehozunk egy új csomópontot feltöltjük értékkel az info mezőt Push (topptr, a) NodeType newnode newnode=create() newnode->info=a!!!! int main() {NodeType *node=null; } a kapcsolatmezőbe bemásoljuk a legfelső elem címét newnode->next=topptr 3 NULL newnode 2 topptr 1

24 A verem (stack) Verembe (push): egy elem bevitele a verembe (a verem tetejére ). létrehozunk egy új csomópontot feltöltjük értékkel az info mezőt Push (topptr, a) NodeType newnode newnode=create() newnode->info=a!!!! int main() {NodeType *node=null; } a kapcsolatmezőbe bemásoljuk a legfelső elem címét ez lesz a legfelső elem newnode->next=topptr topptr=newnode 3 NULL topptr=newnode topptr 2 1

25 A verem (stack) Veremből (pop): a verem tetején található elem kivétele a veremből. Csak akkor tudunk elemet kivenni, ha a verem nem üres Pop (topptr) 3 topptr 2 1

26 A verem (stack) Veremből (pop): a verem tetején található elem kivétele a veremből. Csak akkor tudunk elemet kivenni, ha a verem nem üres Kimentjük a legfelső elem címét és hasznos információját Pop (topptr) NodType auxnode int auxinfo auxnode=topptr auxinfo=topptr->info auxnode 3 topptr 2 1

27 A verem (stack) Veremből (pop): a verem tetején található elem kivétele a veremből. Csak akkor tudunk elemet kivenni, ha a verem nem üres Kimentjük a legfelső elem címét és hasznos információját A veremmutató pointer a következő elemre fog mutatni Pop (topptr) NodType auxnode int auxinfo auxnode=topptr auxinfo=topptr->info topptr=topptr->next auxnode 3 2 topptr topptr 1

28 A verem (stack) Veremből (pop): a verem tetején található elem kivétele a veremből. Csak akkor tudunk elemet kivenni, ha a verem nem üres Kimentjük a legfelső elem címét és hasznos információját A veremmutató pointer a következő elemre fog mutatni Kitöröljük a legfelső elemet (hely felszabadítása) Visszatérítjük a kitörölt elem hasznos információját Pop (topptr) NodType auxnode int auxinfo auxnode=topptr auxinfo=topptr->info topptr=topptr->next free(auxnode) return auxinfo auxnode topptr topptr

29 A verem (stack) Verem legfelső eleme (top): a verem tetején található elem visszatérítése. Csak akkor sikeres, ha a verem nem üres Top (topptr) return topptr->info; 3 topptr 2 1

30 Verem dinamikus implementálása function.h typedef struct NodeType{ int info; struct NodeType *next; }NodeType; NodeType* create(); void push(nodetype** topptr, int data); int top(nodetype*topptr); int pop(nodetype**topptr); int isempty(nodetype *topptr);

31 Verem dinamikus implementálása function.c NodeType *create() { NodeType *newnode = (NodeType *) malloc(sizeof(struct Node *)); newnode->next = NULL; return newnode; }

32 Verem dinamikus implementálása void push(nodetype **topptr, int data) { NodeType *newnode = create(); newnode->info = data; newnode->next = *topptr; *topptr=newnode; }

33 Verem dinamikus implementálása int top(nodetype*topptr) {ha nem üres return topptr->info; } int pop(nodetype**topptr) {ha nem üres {NodeType *aux; int auxinfo; aux = *topptr; *topptr = aux->next; auxinfo = aux->info; free(aux); return auxinfo; }

34 A várakozási sor (QUEUE) a hozzáférés a sor elemeihez a sor elejétől indulva valósítható meg az elemek az érkezésük sorrendjében tárolódnak és ebben a sorrendben érhetők el létező elemet csak a sor elejéről távolíthatunk el új elemet csak a sor végére szúrhatunk be

35 A várakozási sor (Queue) Értékhalmaz: (O(1)). Queue a sor typedef struct NodeType {int info; struct NodeType *next; } NodeType; NodeType *front, *last;!!!! int main() {NodeType *first=null; last=null;} Érték Saját cím Következő elem címe

36 A várakozási sor (QUEUE) Értékhalmaz: Üres?: igaz, ha a sor eleje és a vége is a NULL pointer IsEmpty (first) if first=null then return true else return false first=null last=null (főprogramban) Inicializálás: egy új csomópont helyfoglalása, a kapcsolattartó mező értéke NULL Create () uj_elem helyfoglálása uj_elem->next=null

37 A várakozási sor (Queue) Új elem bevitele a Sorba (insert): egy elem bevitele a sorba (a sor végére) létrehozunk egy új csomópontot feltöltjük értékkel az info mezőt Insert(first, last, a) NodeType newnode newnode=create() newnode->info=a first last a newnode NULL ha üres a sor, ez lesz az első és az utolsó elem különben: az utolsó elemet összekötjük az új elemmel az utolsó elem címe az új elem címe lesz if (IsEmpty(first)) {first=newnode last=newnode } Else { last->next=newnode; last=newnode; } adr1 1 adr2 first adr2 2 adr3 newnode adr3 3 NULL last adr4 4 NULL last

38 A várakozási sor (Queue) Elem törlése a Sorból (delete): egy elem törlése a sorból(a sor elejéről, ha nem üres a sor) A sor első elemének a címét egy segédváltozóba másoljuk, az itt levő hasznos információt pedig egy info mezőnek tipusával megegyező változóba Delete(first) NodeType auxnode if (!IsEmpty(first) { auxnode=first; int auxinfo=first.info auxnode adr1 1 adr2 first last newnode a NULL adr2 adr3 2 adr3 3 NULL Az első elem címe az utána következő elem címe lesz first=fistr->next first first last felszabadítjuk a segédváltozó segítségével a régi első elem által elfoglalt tárrészt Free(auxNode) return auxinfo } else return INT_MIN;

39 Egyszeresen láncolt lista Egyszeresen láncolt lista=várakozási sor + elem törlése elölről +???

40 Dokumentáció Cormen-Lieserson-Rivest-Stein.-.Uj.algoritmusok.pdf