1 Datastructuren Lijstjes (Stacks & Queues) Onderwerp 7.

Presentatie over: "1 Datastructuren Lijstjes (Stacks & Queues) Onderwerp 7."— Transcript van de presentatie:

1 1 Datastructuren Lijstjes (Stacks & Queues) Onderwerp 7

2 2 Dit onderwerp  Pointers en objecten  ADT versus Datastructuur  Datastructuren voor dynamische verzamelingen  ADT: Stack en Queue  Simpele datastructuren voor verzamelingen  Gelinkte Lijsten  Implementatie van Stacks en Queues

3 3 1 Inleiding: Pointers en Objecten Datastructuren en Abstracte Datatypes (ADT’s)

4 4 Pointers en Objecten  In Java (bijv.) implementeer je pointers vaak met ingesloten objecten  Pointer: pijl/verwijzing naar ander (of hetzelfde) object  Class Lijst  Integer x  Lijst volgende Datastructuren 462

5 5 ADT versus Datastructuur  Datastructuur  is een systematische manier van organiseren van data en toegang verlenen tot diezelfde data.  Abstract data type  is een model van een datastructuur waarin gespecificeerd is: type van de data operaties ter ondersteuning van de datastructuur de types van de parameters van deze operaties  Een abstract data type concentreert zich op functionaliteit, niet op tijd. Datastructuren

6 6 Voorbeeld: Priority Queue vs Heap  ADT: Priority Queue  Operaties:  Insert(S,x)  Maximum(S)  Extract-Max(S)  Increase-Key(S,x,k)  Datastructuur: Heap  Implementeert al deze operaties efficient  Insert: O(lg n) mits array groot genoeg  Maximum: O(1)  Extract-Max: O(lg n)  Increase-Key: O(lg n)  Maar er kunnen ook andere datastructuren gebruikt worden

7 7 Priority queue met gewoon array  ADT: Priority Queue  Operaties:  Insert(S,x)  Maximum(S)  Extract-Max(S)  Increase-Key(S,x,k)  Datastructuur: Array  Insert:  Zolang array groot genoeg is, voeg element achteraan aan, en zet PQ-Size(S)++  O(1)  Extract-Max: O(n)  max = S[1]; pm = 1  for i=2 to PQ-Size(S) do if S[i] > max then max = S[i]; pm=1  Verwissel S[pm] en S[PQ- Size(S)]  PQ-Size(S)--;  Return max;  Maximum: O(n)  Increase-Key(S,x,k): O(1) (als je weet waar x staat)

8 8 Moraal  Van een ADT zijn verschillende implementaties door een datastructuur mogelijk  Soms is de ene datastructuur met de ene soort operaties sneller en de andere datastructuur met de andere soort operaties sneller  Welke je neemt hangt dus af van gebruik

9 9 2 Dynamische verzamelingen

10 10 Dynamische Verzamelingen  Verzameling elementen waar we operaties op uitvoeren, bijvoorbeeld:  Invoegen van nieuw element  Verwijderen van element  Vragen aan stellen, bijvoorbeeld: is er een element met keywaarde x?  Java:  Set Interface  C# …

11 11 Verschillende datastructuren voor dynamische verzamelingen  Hangt af wat welke operaties we doen willen (en hoe snel welke operatie)  Invoegen  Weglaten  Zoeken van element op key  Element met kleinste/grootste key  Weglaten van eerst/laatst ingevoegde element  …

12 12 Allerlei soorten dynamische datastructuren  Wat wil je erop doen?  Dynamische verzameling (Set):  Invoegen van element  Weglaten van element  Testen of element in verzameling zit Of “Map”-variant: geef extra gegevens van element  Vaak gekozen: Hashtabel (komt hierna)  Opleveren van langst geleden ingevoegde element (Queue)  Opleveren van laatst ingevoegde element (Stack)  Kleinste, grootste element, “next”: element dat net groter / kleiner is, …: (gebalanceerde) bomen

13 13 3 Stack

14 14 Stack  Stapel, vergelijkbaar met “stapel borden”  Wat je er ‘t laatst opzet haal je er ‘t laatst vanaf  LIFO: “Last In First Out”

15 15 Stack (stapel)  De Stack is een Abstract Data Type  “Dynamic Set” (dynamische verzameling): verzameling die verandert doordat er elementen in en uit gaan op een bepaalde manier  Gedefinieerd door een drietal operaties:  STACK-EMPTY(S) Geeft een Boolean: true als de stack geen elementen bevat, false als er wel elementen in de stack zitten  PUSH(S,x) Zet het element x “bovenop” de stack  POP(S) Levert het “bovenste” element van de stack, en haalt dat element ervanaf. D.w.z., verwijdert en levert dat element van alle elementen in de stack dat als laatste toegevoegd werd en nog niet ge-pop-ed is. Datastructuren

16 16 Toepassingen Stack  In veel algoritmen gebruikt  Onder andere: implementatie van recursie

17 17 Implementatie 1 van STACK  Met array als je maximum grootte weet STACK-EMPTY(S)  if top(S) == 0  then return true  else return false PUSH(S,x)  top(S)++; S[top(S)]=x  {Kan fout gaan als array te klein…} POP(S)  if STACK-EMPTY(S)  then return “fout: stack leeg”  else  top(S)--;  Return S[top(S)+1]

18 18 Implementatie 2 van STACK  Met Pointers (Gelinkte lijst)  Zie volgende sheets  Nadelen: wat lastiger (en slechtere constante factor)  Voordelen: geen maximum formaat en kleine stack heeft weinig geheugen nodig

19 19 Object met pointer  Class Stackelement  int gegeven;  String nogeengegeven;  …  Stackelement next;

20 20 4 8 3 2 De stack heeft een pointer die naar de top van de stapel wijst top(S)

21 21 POP(S) 4 8 3 2 8 3 2 top

22 22 Push(S,4) 4 8 3 2 8 3 2 top

23 23 IsEmpty(S)  Commando uit programmeertaal dat test of pointer wijst naar niet-bestaand object  In Boek-pseudocode: NIL  I.e.: top(S)==NIL  Sommige implementaties gebruiken een “dummy” object als eind van de stack 8 3 top

24 24 4 Queue

25 25 Queue  Rij, vergelijk met rij voor loket  Wie het eerst komt, is ook het eerst weer weg  FIFO: “First In First Out”

26 26 Operaties op Queue  Enqueue(Q,x)  Voeg element toe aan Queue  Dequeue(Q)  Is-Empty(Q)

27 27 Implementatie van Queue op array  Queue heeft drie variabelen:  lengte(Q): grootte array (1 … lengte(Q))  kop(Q) (head; begin)  staart(Q) (tail; eind)  Code hier test niet op lege queue’s (werkcollege)  Kan fout gaan als array te klein is… EnQueue(Q,x)  Q[staart(Q)] = x  if (staart(Q) == lengte(Q))  then staart(Q) = 1  else staart(Q)++ Dequeue(Q)  x = Q[kop(Q)]  if (kop(Q)== lengte(Q))  then kop(Q) = 1  else kop(Q) ++

28 28 528631 kop staart

29 29 Implementatie 2 van Queue: met pointers  Voordelen en nadelen (tov array implementatie) net als voor Stacks  Vanwege voordelen worden vaak pointers gebruikt

30 30 Queue als gelinkte lijst 873125 kop staart

31 31 Pseudocode  Class Queue  QueueElement kop;  QueueElement staart  Class QueueElement  Allerlei gegevens …;  QueueElement volgende

32 32 Dequeue(Q) 873125 kop staart 73125 kop staart Returnwaarde 8

33 33 Enqueue(Q,5) 87312 kop staart 873125 kop staart

34 34 Implementatie met groter wordende arrays  Vaak ook gebruikt:  Neem een initiele grootte van de array  Als die te klein blijkt te worden:  Neem een grotere array, en kopieer alles naar die grotere array Bijvoorbeeld: twee keer zo grote array

35 35 5 Nog even: enkel- en dubbelgelinkte lijsten

36 36 Gelinkte lijst en dubbel gelinkte lijst 87312 6021

37 37 Dubbelgelinktelijstobject  Class DGLO  Allerlei interessante gegevens, bijvoorbeeld int key;  DGLO vorige; (prev) Ontbreekt in Enkelgelinkte lijst  DGLO volgende; (next)  De lijst zelf is een object met in elk geval  DGLO kop; (head)  DGLO staart; (tail)

38 38 Zoeken in gelinkte lijst List-Search(L,k)  x = kop(L)  while (x != NIL and key(x) != k) do  x = volgende(x);  return x;  Geeft object met k als dat bestaat, anders NIL

39 39 Invoegen in dubbelgelinkte lijst List-Insert(L,x)  volgende(x)=kop(L);  if kop(L) != NIL  then vorige(kop(L))=x;  kop(L) = x;  vorige(x) = NIL  Hier code om object x aan het begin van de lijst in te voegen  In sommige toepassingen (bijv. als de lijst gesorteerd gehouden wordt) wil je ook middenin invoegen

40 40 Weglaten List-Delete(L,x)  if vorige(x)!= NIL  then volgende(vorige(x)) = volgende(x);  else kop(L)= volgende(x)  if volgende(x)!= NIL  then vorige(volgende(x)) = vorige(x); 6021 021

41 41 Voordeel van dubbelgelinkte lijsten  Met name: het is makkelijk om een object middenin de lijst weg te laten  Nadeel: meer pointers

42 42 Sentinels (stootblokken)  Speciale objecten aan kop en staart van de dubbelgelinkte lijst kunnen soms handig zijn 602!

43 43 7 Combinaties van datastructuren

44 44 Datastructuren aan elkaar plakken  Voor veel toepassingen gebruik je combinaties van datastructuren  Voorbeeldje: leger(tjes) in strategisch spel  Er is een kaart: iedere locatie heeft paar coordinaten (x,y)  Er zijn legers: die hebben eigenschappen als: land, sterkte, naam, ervaring, functie, etc.  Elk leger staat op een locatie  Er kunnen meer legers op dezelfde locatie staan  Functies: Speler kan al zijn legers bekijken op volgorde waarop ze ontstaan zijn Speler kan locatie bekijken en daar al zijn legers zien Leger kan verdwijnen (door “disband”-actie of verlies in veldslag) Legers bewegen naar andere locaties

45 45 Objecten voor voorbeeld  Kaart is array [0 … ?, 0 … ?] van locatie  Locatie is Object met:  Eigenschappen als soort gebied, etc  Pointer naar dubbelgelinkte lijst van legers Dubbelgelinkt maakt makkelijk om legers te laten verdwijnen  Leger is object met  Eigenschappen als sterkte, naam, etc.  Pointers voor dubbelgelinkte lijst van locatie  Pointers voor dubbelgelinkte lijst van legers van speler Dus 4 pointers (verwijzingen naar Leger-objecten)  Elke actie is een flink, maar constant aantal operaties…

46 46 Conclusies  Sommige programmeertalen hebben dit soort datastructuren voorgebakken  Verschilt per taal  Soms (niet altijd) beter dan zelf maken…  Datastructuren voor verzamelingen  Lijsten, queues en stacks  Wat komt:  Datastructuren die ons snel laten zoeken of een element voorkomt en invoegen en weglaten: Bomen Hash-tabellen