Datastructuren: stapels, rijen en binaire bomen

Transcriptie

1 Programmeermethoden : stapels, rijen en binaire bomen Walter Kosters week 12: november kosterswa/pm/ 1

2 en Vierde programmeeropgave Othello programmeren we als volgt: week 1: pointerpracticum, opgave lezen week 2: files (makefile), klassen, bord bouwen, zetten week 3: spelen, menu [stapels, vervolgpartijen] week 4: experiment (gnuplot), verslag kosterswa/pm/op4pm.php 2

3 Inleiding In de informatica worden Abstracte DataTypen (ADT s) zoals stapels, rijen en bomen veelvuldig gebruikt. Bij de afwikkeling van recursie komen bijvoorbeeld stapels goed van pas. De OOP-filosofie sluit hier mooi op aan. 3

4 Abstract DataType Een DataType bestaat uit een domein (een collectie waarden, al dan niet met structuur), in combinatie met een aantal basisoperaties die op dit domein gedefinieerd zijn. We spreken van een Abstract DataType als de implementatie van de operaties is afgeschermd van de gebruiker. Voorbeeld 1: De gehele getallen (int in C ++ ), met basisoperaties zoals +, en. De gebruiker kan deze operaties wel gebruiken, maar weet niet (en hoeft ook niet te weten) hoe deze precies in C ++ zijn geïmplementeerd. Voorbeeld 2: Verzamelingen, zoals verzamelingen gehele getallen tussen 0 en n: {3, 6, 10}. 4

5 Verzamelingen Bekijk het datatype Verzameling (Set) waarvan het domein bestaat uit verzamelingen gehele getallen tussen 0 en n. Een verzameling is ongeordend en bevat allemaal verschillende elementen. Als basisoperaties op deze verzamelingen definiëren we: een lege verzameling aanmaken (of een bestaande leeg maken), kijken of de verzameling leeg is, testen of een gegeven getal erin zit, een getal eraan toevoegen, een getal eruit halen. 5

6 Klasse verzameling 1 class verzameling { public: verzameling ( ); // constructor bool isleeg ( ); // is V leeg? bool ziterin (int i); // zit i in V? void erbij (int i); // stop i in V void eruit (int i); // haal i uit V... private: // de implementatie wordt afgeschermd bool inhoud[n]; // n een constante };//verzameling We implementeren een verzameling V dus met behulp van een array inhoud, waarbij inhoud[i] == true i V. Met behulp van de basisoperaties kunnen we andere functies schrijven, zoals void verzameling::doorsnede (A,B). 6

7 Klasse verzameling 2 verzameling::verzameling ( ) { for ( int i = 0; i < n; i++ ) inhoud[i] = false; }//verzameling::verzameling bool verzameling::isleeg ( ) { for ( int i = 0; i < n; i++ ) if ( inhoud[i] ) return false; return true; }//verzameling::isleeg bool verzameling::ziterin (int i) { return inhoud[i]; }//verzameling::ziterin void verzameling::erbij (int i) { inhoud[i] = true; }//verzameling::erbij void verzameling::eruit (int i) { inhoud[i] = false; }//verzameling::eruit 7

8 Klasse verzameling 3 // de verzameling *this wordt gelijkgemaakt aan A door B void verzameling::doorsnede (verzameling & A, verzameling & B) { for ( int i = 0; i < n; i++ ) { if ( A.ziterin (i) && B.ziterin (i) ) erbij (i); // oftewel this->erbij (i); }//for }//doorsnede In main (voor {6,10} {3,6} = {6}): verzameling een, twee, drie; een.erbij (10); een.erbij (6); // vul een = {6,10} twee.erbij (3); twee.erbij (6); // vul twee = {3,6} drie.doorsnede (een, twee); // drie wordt de doorsnede // van een en twee: {6} 8

9 Stapels Een stapel (stack; denk aan een stapel boeken) is een reeks elementen van hetzelfde type, bijvoorbeeld gehele getallen, met de volgende toegestane operaties: een lege stapel aanmaken, testen of de stapel leeg is, een element toevoegen (push), het laatst-toegevoegde element eruithalen (pop), soms: kijken of de stapel al vol is. Een stapel heeft dus de LIFO-eigenschap: LIFO = Last In First Out. Toevoegen en verwijderen gebeurt derhalve aan dezelfde kant: de bovenkant. 9

10 Klasse stapel class stapel { // stapel die gehele getallen bevat public: stapel ( ); bool isstapelleeg ( ); void zetopstapel (int); // push void haalvanstapel (int&); // pop... private: // implementatie met pointers of array };//stapel C ++ aanroep: abstracte notatie: S.zetopstapel (768); S 768; S.haalvanstapel (jaartal); jaartal S; 10

11 Stapel via pointers 1 push pop bovenste NULL 11

12 Stapel via pointers 2 We hebben een extra type nodig voor de vakjes waaruit de pointerlijst bestaat. De vakjes zijn opgebouwd uit een veld info voor een geheel getal en een veld volgende voor de rest van de stapel. class vakje { // een struct mag ook public: // constructor (een destructor hoeft misschien niet) vakje ( ) { // beter niet "inline" info = 0; volgende = NULL; }// constructor vakje int info; vakje* volgende; };//vakje 12

13 Stapel via pointers 3 De stapel als enkelverbonden lijst: class stapel { // de stapel zelf public: stapel ( ) { bovenste = NULL; }// maak lege stapel ~stapel ( ); // destructor void zetopstapel (int); // push void haalvanstapel (int&); // pop bool isstapelleeg ( ) { // is stapel leeg? return ( ( bovenste == NULL )? true : false ); // of: if ( bovenste == NULL )... }//isstapelleeg... private: // het begin van de lijst is vakje* bovenste; // de bovenkant van de stapel };//stapel 13

14 Stapel via pointers 4 void stapel::zetopstapel (int getal) { vakje* temp = new vakje; temp->info = getal; temp->volgende = bovenste; bovenste = temp; }//stapel::zetopstapel void stapel::haalvanstapel (int & getal) { vakje* temp = bovenste; getal = bovenste->info; bovenste = bovenste->volgende; delete temp; }//stapel::haalvanstapel // push // pop NB Bij deze haalvanstapel hoef je er niet op te letten of de stapel leeg is, dat moet de gebruiker via isstapelleeg zelf maar doen... 14

15 Stapel via pointers 5 En de destructor die de pointerlijst netjes afbreekt: stapel::~stapel ( ) { int getal; while (! isstapelleeg ( ) ) haalvanstapel (getal); }//stapel::~stapel Deze destructor wordt vanzelf aangeroepen als de betreffende variabele ophoudt te bestaan, dus aan het eind van de functie waarin de variabele gedeclareerd is. Vaak wordt hiervan een aparte verwijder-functie gemaakt, met destructor: stapel::~stapel ( ) { verwijder ( ); } 15

16 Stapel via een array 1 const int MAX = 100; class stapel { // voor maximaal MAX integers public: stapel ( ) { bovenste = -1; } // constructor void zetopstapel (int); void haalvanstapel (int&); bool isstapelleeg ( ) { return ( bovenste == -1 ); }... private: int inhoud[max]; int bovenste; // index bovenste waarde };//stapel 16

17 Stapel via een array 2 void stapel::zetopstapel (int getal) { bovenste++; inhoud[bovenste] = getal; }//stapel::zetopstapel void stapel::haalvanstapel (int & getal) { getal = inhoud[bovenste]; bovenste--; }//stapel::haalvanstapel Er is eigenlijk ook een memberfunctie vol nodig, bijvoorbeeld in het private-gedeelte gedefinieerd. Deze functie wordt dan in zetopstapel aangeroepen. bool stapel::vol ( ) { return ( bovenste == MAX - 1 ); }//stapel::vol 17

18 Stapel: gebruik in functies void haalgrootstegetaluitstapel (stapel & S, int & grootste) { stapel hulp; int x; if (! S.isstapelleeg ( ) ) { S.haalvanstapel (grootste); hulp.zetopstapel (grootste); while (! S.isstapelleeg ( ) ) { S.haalvanstapel (x); if ( x > grootste ) grootste = x; hulp.zetopstapel (x); }//while while (! hulp.isstapelleeg ( ) ) { hulp.haalvanstapel (x); if ( x!= grootste ) S.zetopstapel (x); }//while }//if }//haalgrootstegetaluitstapel Merk op dat de precieze implementatie van de stapel er niet toe doet, evenmin als in het volgende voorbeeld. 18

19 Stapel: gebruik in main int main ( ) { // een main die de stapel gebruikt stapel S; int getal = 0; while ( getal >= 0 ) { // zet getallen > 0 op stapel S.drukaf ( ); // nog te schrijven memberfunctie cout << "getal > 0: push; = 0: pop; < 0 stop" << endl; cin >> getal; if ( getal > 0 ) S.zetopstapel (getal); else if ( ( getal == 0 ) && (! S.isstapelleeg ( ) ) ) { S.haalvanstapel (getal); cout << getal << " van stapel gehaald " << endl; }//if }//while return 0; }//main 19

20 STL Stapels In de Standard Template Library (STL) zitten ook al complete stapels ( stacks ): #include <stack> stack<int> S; S.push (1989); S.push (2017); while (! S.empty ( ) ) { cout << S.top ( ) << endl; S.pop ( ); }//while Tussen < komt. > staat het soort elementen dat op de stapel In de STL zitten overigens bijvoorbeeld ook vectoren, verzamelingen ( sets ) en rijen ( queues ). 20

21 Rijen Een rij (queue; denk aan een rij voor een kassa) is een reeks elementen van hetzelfde type, bijvoorbeeld karakters, met de volgende toegestane operaties: een lege rij aanmaken, testen of de rij leeg is, een element toevoegen (push), het eerst-toegevoegde element eruithalen (pop), soms: kijken of de rij al vol is. Een rij heeft dus de FIFO-eigenschap: FIFO = First In First Out. Toevoegen en verwijderen gebeuren dus aan verschillende kanten: achteraan respectievelijk vooraan. 21

22 Bomen Definitie: een boom is een samenhangende ongerichte graaf zonder cykels, met één speciale knoop: de wortel. wortel A S D F G H J K L Z X C V B N M bladeren De kinderen van A zijn S, D, F en G. S is de ouder van J. Verder zijn K, L, V, B, N en M de afstammelingen van F. En H, S en A zijn de voorouders van X. 22

23 Binaire bomen Een binaire boom is een boom waarin elke knoop ofwel nul, ofwel één, ofwel twee kinderen heeft: het linkerkind en het rechterkind. Als een knoop één kind heeft, dan is dit ofwel een linkerkind, ofwel een rechterkind... linkerkind rechterkind één kind: rechterkind Recursief gedefinieerd: een binaire boom is leeg, of bestaat uit een wortel, een linker- en een rechtersubboom. 23

24 Implementatie class knoop { // een struct mag ook public: knoop ( ) { // constructor info = 0; links = NULL; rechts = NULL; } int info; knoop* links; knoop* rechts; };//knoop class binaireboom { public: binaireboom ( ) { wortel = NULL; } void WLR ( ) { preorde (wortel); } void LWR ( ) { symmetrisch (wortel); }... private: knoop* wortel; void preorde (knoop* root); void symmetrisch (knoop* root);... };//binaireboom 24

25 Wandelingen void binaireboom::preorde (knoop* root) { // WLR if ( root!= NULL ) { // Wortel-Links-Rechts cout << root->info << endl; preorde (root->links); preorde (root->rechts); }//if }//preorde void binaireboom::symmetrisch (knoop* root) { // LWR if ( root!= NULL ) { // Links-Wortel-Rechts symmetrisch (root->links); cout << root->info << endl; symmetrisch (root->rechts); }//if }//symmetrisch 25

26 Knopen tellen We tellen recursief het aantal knopen van een binaire boom met ingang wortel. Aanroep: int tellen = aantal (wortel); int aantal (knoop* root) { if ( root == NULL ) // lege boom return 0; else return ( 1 + aantal (root->links) + aantal (root->rechts) ); }//aantal Hier wordt eigenlijk een preorde-wandeling gedaan. 26

27 Spelbomen Bomen, en niet alleen binaire, worden vaak gebruikt om spellen als schaken en go te analyseren ( α-β-algoritme ). Boter, kaas en eieren twee spelers: MAX (X) en MIN (O) 27

28 Aantal partijen Het aantal vervolgpartijen vanuit een gegeven positie in de wortel is het aantal bladeren in deze boom. Het kan berekend worden zonder de boom echt te maken, zie het college over recursie! Voor Boter, kaas en eieren is dit , waarvan overigens gewonnen door de beginspeler, door de ander en remise. En voor zetten terugnemen kun je een stapel gebruiken: elke keer als je een zet doet, zet je de oude positie (oftewel stand) op de stapel! 28

29 makefile Als je C ++ -code over meerdere files verdeelt, helpt een makefile bij het compileren (aanroep: make). Stel je hebt: file oth.h class oth {... void print ( ); };//oth file oth.cc #include "oth.h" // implementatie van // prototypes uit // oth.h void oth::print ( ) {... }//oth::print file hoofd.cc #include <iostream> #include "oth.h"... int main ( ) { oth X; X.print ( );... }//main De makefile ziet er dan bijvoorbeeld uit als (let op tabs!): all: oth.o hoofd.o TAB g++ -Wall -o othello oth.o hoofd.o oth.o: oth.cc oth.h TAB g++ -Wall -c oth.cc hoofd.o: hoofd.cc oth.h TAB g++ -Wall -c hoofd.cc Zie make-dictaat! 29

30 Opgave van de week 1 Opgave 4 van het tentamen van 8 januari 2007: Gegeven is het volgende type: class info { public: info* volgl; info* volgg; char letter; int getal; }; Met behulp hiervan worden rijtjes (lijstjes) met letter-getal combinaties opgebouwd; alle gebruikte letters en getallen verschillen onderling. Het veld volgl bevat een pointer naar het info-object met de eerstvolgende alfabetisch grotere letter (of NULL), het veld volgg een pointer naar het object met het eerstvolgende grotere getal (of NULL). Een voorbeeld (ingang van type info*; deze wijst steeds het object met het kleinste getal aan), waarbij volgg de meest rechtse pointer in ieder object is: ingang F 16 NULL B 42 A 44 D 66 NULL Het object met B en 42 erin heeft hier een pointer volgl naar het object met D en 66, en een (horizontale) pointer volgg naar het object met A en 44. a. Schrijf een C ++ -functie voegtoe (ingang,let,get) die een nieuw object met getal get en letter let erin vooraan de structuur (met ingang van type info* als ingang) toevoegt. Neem aan dat het eerste getal uit de oude lijst groter is dan get. Maak de nieuwe volgl-pointer NULL, en verander (nog) niets aan de andere volgl-pointers. 30

31 Opgave van de week 2 Opgave 4 van het tentamen van 8 januari 2007, vervolg: b. Schrijf een C ++ -functie verwijder (ingang) die het eerste object uit de lijst (met ingang van type info* als ingang) verwijdert indien in dat vakje niet de letter D en het getal 66 zitten. Denk aan de lege lijst. Verander niets aan volgl-pointers. c. Schrijf een C ++ -functie verwissel (ingang) die eerste en tweede (via de volggpointer) object verwisselt (dus niet de inhouden), indien deze bestaan en het getal uit het eerste object groter is dan dat uit het tweede, en anders niets doet. d. In de functies bij a, b en c staat in de heading de parameter ingang. Deze heb je call by value of call by reference doorgegeven (met een &). Maakt het voor de werking van deze functies verschil uit of die & erbij staat? Leg duidelijk uit. e. Vul de functie voegtoe van a aan zodat na afloop alle volgl-pointers goed staan. Neem aan dat er minstens één letter < let in de lijst voorkomt. Tip: zoek de grootste kleinere. 31

32 Tot slot werk aan de vierde programmeeropgave de deadline is op maandag 10 december 2018 bezoek vragenuren en (werk)colleges het werkcollege van maandag 17 december is verplaatst naar vrijdag 14 december, 13:30 uur lees dictaat Hoofdstuk 5 maak opgaven 57/61 uit het opgavendictaat nog twee colleges: Algoritmen en Talen: Python,... kosterswa/pm/ 32