Hoofdstuk 2. Week 4: Datastructuren. 2.1 Leesopdracht. 2.2 Bomen. 2.3 Definitie
|
|
- Vincent van der Laan
- 8 jaren geleden
- Aantal bezoeken:
Transcriptie
1 Hoofdstuk 2 Week 4: Datastructuren 2.1 Leesopdracht In het hoorcollege komen lijsten en bomen aan de orde. De eerste datastructuur komt in het boek in bladzijden aan de orde. In dit dictaat komt uitsluitend de theorie van bomen aan de orde. 2.2 Bomen De lineaire lijst heeft als grote bezwaar, dat doorzoeken van de lijst evenredig toeneemt met de lengte van de lijst. In een twee keer zo lange lijst moeten over het algemeen twee keer zoveel element-vergelijkingen worden gedaan. Eerder hebben we een efficiënter zoekalgoritme besproken, nl. binary search. Hiervoor is het nodig dat de gegevens geordend aanwezig zijn. Zelfs bij een geordende lijst is binary search echter onmogelijk omdat we het midden van de lijst niet zo eenvoudig kunnen vinden. We zouden graag een structuur willen hebben, die dat wel kan. Zo n structuur is er, nl. de boomstructuur (in het Engels: tree). 2.3 Definitie We kunnen de volgende definitie vinden in de literatuur: Een boom bestaat uit een (eventueel lege) verzameling gerichte verbindingen tussen tweetallen punten. Eén punt, de zg. wortel (root), heeft geen inkomende verbindingen. Vanuit de wortel is elk ander punt van de boom op precies één manier langs de gerichte verbindingen bereikbaar. Een punt zonder uitgaande verbindingen wordt wel blad (leaf ) genoemd. Een willekeurig punt een knoop (node). Evenals met lijsten het geval was, hebben we hier een recursieve structuur: wijzen we een willekeurig punt van de boom aan als wortel, dan is de onderliggende structuur 1
2 wederom een boom (en wel een subboom (subtree van de originele boom). 2.4 Binaire bomen We zullen hier alleen binaire bomen behandelen, d.w.z. dat vanuit elk punt hooguit twee verwijzingen naar subbomen mogelijk zijn. We gaan dus een class SearchTree maken. Eén van de problemen waar we binnen een object geörienteerde taal tegenaan kunnen lopen is dat we ook een lege boom als een object uit de class SearchTree willen beschouwen. Een lege boom is echter het handigst als een null referentie te beschouwen. Je kunt echter geen methods van een null referntie aanroepen. De handigste aanpak onder deze omstandigheden is om binnen de class SearchTree een private class TreeNode te maken. Deze bevat de eigenlijke boom structuur, terwijl de class SearchTree alleen de wortel van de boom (root die dus null mag zijn) bevat. Iedere method in SearchTree zal dus eerst controleren of de boom leeg is, zonodig zelf actie ondernemen om deze uitzondering te behandelen, en anders de overeenkomstige method uit de private class TreeNode aanroepen. Dit levert de volgende structuur: public class SearchTree private class TreeNode // Data fields private Object info; private TreeNode left; private TreeNode right; // Methods within TreeNode... // Data fields public TreeNode root; // Methods within SearchTree Een voorbeeld van het gebruik van een boomstructuur vinden we in het opslaan van een rekenkundige expressie. Zo kunnen we de expressie: (a b)/(c + (d e)) 2
3 root node / * + a b c - leaf d e Figuur 2.1: Binaire boom voor (a b)/(c + (d e)). in een binaire boom opslaan zoals in aangegeven in figuur 2.1. Uit de boomstructuur volgt direkt de evaluatie volgorde, zodat haakjes overbodig worden. Net als bij lijsten is het ook bij bomen verstandig om niet direct de datastuctuur te manipuleren, maar om methods te gebruiken die de structuur manipuleren. Op deze wijze is het handhaven van de integriteit (correctheid) van de datastructuur een stuk gemakkelijker. Voor bomen met rekenkundige expressies definiëren we daarom de volgende constructor public TreeNode(Object obj, TreeNode leftnode, TreeNode rightnode) info = obj; left = leftnode; right = rightnode; De bovenstaande rekenkundige expressie kunnen we nu gemakkelijk construeren met: root = new TreeNode ( "/", new TreeNode ( "*", new TreeNode( "a"), new TreeNode( "b" ) ), new TreeNode ( +, new TreeNode( "c" ), new TreeNode ( -, new TreeNode( "d" ), new TreeNode( "e" ) ) 3
4 ); ) 2.5 Doorlopen van een binaire boom Er bestaan in principe drie manieren om een boomstructuur te doorlopen: 1 ) preorder - behandel eerst de wortel en dan resp. de linker- en rechter subboom. inorder - behandel eerst de linker subboom, dan de wortel zelf en tot slot de rechter subboom. postorder - behandel eerst de linker resp. rechter subboom en pas dan de wortel. In Java kunnen we bijvoorbeeld het in preorder, inorder of postorder doorlopen van een boom beschrijven alsvolgt: public preorderdosomething ( ) info.dosomething(); if ( left!= null ) left.preorderdosomething( ); if ( right!= null ) right.preorderdosomething( ); public inorderdosomething ( ) if ( left!= null ) left.inorderdosomething( ); info.dosomething(); if ( right!= null ) right.inorderdosomething( ); 1 ) Pre- en postorder is ook te definiëren voor algemene bomen, inorder alleen voor binaire bomen 4
5 public postorderdosomething ( ) if ( left!= null ) left.postorderdosomething( ); if ( right!= null ) right.postorderdosomething( ); info.dosomething(); Indien info.dosomething bestaat uit het afdrukken van het item, ontstaat de volgende uitvoer voor de hiervoor gegeven expressieboom: preorder: / a b + c d e inorder: a b / c + d d postorder: a b / c d e + Zowel de preorder als de postorder uitvoer van deze expressie zijn zonder ambiguïteit te begrijpen. De overeenkomstige prefix, resp. postfix notatie 2 ) is dan ook zonder haakjes te gebruiken. De bij de inorder uitvoer behorende infix notatie heeft zo nu en dan haakjes nodig (of strikte prioriteitsregels) om ambiguiteit te voorkomen. De postfix notatie staat wel bekend als de omgekeerde Poolse notatie. 3 ) 2.6 Geordende lijsten Tot nog toe hebben we ons bij lijsten niet bekommerd om de volgorde van de elementen. Vaak willen we dat de elementen in een lijst in opklimmende grootte geordend zijn. We spreken dan van een geordende lijst. Voorwaarde is dat de objecten in de lijst Comparable zijn. De insert moet dan als volgt geimplementeerd worden: 2 ) Prefix-notatie: de operator voor de operanden, postfix: de operator achter de operanden en infix: de operator ertussen in (de laatste alleen voor binaire operatoren). 3 ) De notatie is bedacht door de Pool Lukasiewicz, maar wordt niet Lukasiewicz-notatie genoemd omdat de naam zo moeilijk uit te spreken en te onthouden is. 5
6 public void insertordered( Comparable e ) ListIterator iter = this.listiterator(); while (iter.hasnext()) if ( e.compareto((comparable) iter.next()) < 0 ) if (iter.hasprevious()) iter.previous(); break; iter.add(e); Het nadeel van een geordende lijst is dat het toevoegen van een nieuw element aan de lijst wat meer rekentijd kost, maar het voordeel is dat een groot aantal bewerkingen minder tijd kosten. Bijvoorbeeld: Minimum: het zoeken van het kleinste element kan in constante tijd O N 0, immers dit element staat vooraan in de lijst. Uniek: het verwijderen van doublures, elementen die twee of meer keren voorkomen, uit de lijst kost voor ongeordende lijsten O N 2 tijd en voor geordende lijsten O N tijd. Gelijkheid: de gelijkheidstest van twee lijsten kan in orde O N tijd, voor ongeordende lijsten is minimaal O N 2 tijd nodig. 2.7 Een geordende boom In de vorige paragraaf bleek, dat zelfs met een geordende lijst geen efficiënt zoekalgoritme mogelijk is. Ook met een geordende lijst blijft een zoekalgoritme O N. We kunnen (onder bepaalde voorwaarden 4 )) laten zien, dat in een geordende boom een zoekalgoritme mogelijk is van O log N. Duizend keer zoveel elementen betekent nu log keer zoveel zoekacties. Voorwaar een hele verbetering. We zullen nu eerst definiëren, wat we onder een geordende boom zullen verstaan. 5 ) We gaan hierbij uit van de ordeningsrelatie. 4 ) Hierbij moet de boom gebalanceerd zijn. D.w.z. dat in elke knoop de subbomen hooguit één in diepte verschillen. Over balanceren van bomen zullen we hier niet spreken. We kunnen dus niet garanderen dat de zoekalgoritmen O log N zijn. 5 ) Een veel gebruikte term voor een geordende boom is search tree, zodat we kunnen zeggen dat tree search needs search trees. 6
7 Een boom heet geordend (m.b.t. ) als alle waarden in de knopen van de linkersubboom niet groter zijn dan de waarde in de wortel van t en de waarde in de wortel in niet groter is dan enige waarde van de knopen in de rechtersubboom. Bovendien zijn de linker- en rechtersubboom weer geordend. Zoeken in een boom kan nu vrij eenvoudig worden geprogrammeerd. Het algoritme vertoont enige verwantschap met binary search: ook hier wordt in elke stap het aantal te doorzoeken elementen gehalveerd, hetgeen in een O log N algoritme resulteert. De boom wordt nu vanaf de wortel doorlopen, en wel zodanig, dat in iedere knoop wordt beslist of de zoekactie in de linker- of de rechtersubboom moet worden voortgezet. Als resultaat levert searchitem een verwijzing naar de knoop waarin het gezochte element staat; echter als het element niet gevonden wordt levert searchitem de waarde null op. public static TreeNode searchitem( TreeNode tree, Comparable e ) //Pre : true //Post: searchitem = null ( searchitem.info = e ) if (tree == null) return null; // niets gevonden int test = e.compareto( (Comparable) tree.info); if (test == 0) // als e == tree.info return tree; // raak!! if (test<0) return searchitem( tree.left, e); // als e < tree.info // links zoeken return searchitem( tree.right, e); // anders rechts zoeken 2.8 Basisoperaties op binaire zoekbomen De basisoperaties op bomen verschillen niet veel van de basisoperaties op geordende lijsten. Het is zelfs verstandig om de interfacing m.b.t. bomen zo veel mogelijk gelijk te kiezen aan 7
8 de interfacing m.b.t. geordende lijsten; immers we kunnen dan bomen en lijsten gebruiken als verschillende implementaties behorende bij dezelfde interface. add - het toevoegen van een element in een binaire zoekboom. clone - het copieren van een binaire zoekboom. isempty - controle of de boom leeg is. join - het samenvoegen van twee binaire zoekbomen. remove - verwijder node uit boom. tostring - het converteren naar een string. first - het kleinste element last - grootste element Elementen toevoegen in een geordende boom kan eenvoudig worden uitgeschreven. We maken hiervoor gebruik van onderstaand schema: 1. Als de huidige boom leeg is, wordt het betreffende element als wortel in de huidige boom opgenomen. 2. Is de huidige boom niet leeg, dan wordt het probleem verplaatst naar de linker- of rechter subboom en wel: naar links, indien het wortelelement kleiner is en naar rechts, indien het wortelelement groter is dan het in te voegen element. bij gelijkheid voegen we in dit geval het element niet toe en signaleren dit door als return-waarde false te geven. 6 ) Het schema resulteert in de method add: public boolean add( Object item ) if ( isempty() ) root = new TreeNode( item ); return true; return root.addnode( item ); De recursie wordt afgehandeld door de add method binnen de private class TreeNode: 6 ) Er zijn ook andere keuzes mogelijk als element gelijk is aan het wortelelement. We kiezen hier voor een methode die gelijk is aan die in standaard classes van Java. 8
9 public boolean addnode(object item) // Voegt een element aan de binaire zoekboom toe if ( info.compareto(item) == 0 ) return false; if ( info.compareto(item) > 0 ) // item.key < root.key if ( left == null ) left = new TreeNode(item); return true; // new item added return left.addnode(item); // insert in left tree // item.key >= root.key if ( right == null ) right = new TreeNode(item); return true; // new item added return right.addnode(item); // insert in left tree Voor de implementatie van clone gebruiken we een dergelijke opsplitsing. De clone method van class SearchTree is 9
10 public SearchTree clone() SearchTree t = new SearchTree(); if (! isempty() ) t.root = root.clone(); return t; Die van class TreeNode: public TreeNode clone() TreeNode t = new TreeNode( ((Cloneable)info).clone() ); if ( left!= null ) t.left = left.clone(); if ( right!= null ) t.right = right.clone(); return t; De method join voegt alle elementen van een zoekboom aan een andere zoekboom, die als parameter wordt meegegeven. Deze method volgt ook het voorgaande patroon. In SearchTree hebben we public void join( SearchTree t ) // Combineer twee binaire zoekbomen if (!isempty() ) root.join(t); En in TreeNode: 10
11 public void join( SearchTree t ) // Combineer twee binaire zoekbomen t.insert( (Comparable) info); if ( left!= null ) left.join(t); if ( right!= null ) right.join(t); Bij de implementatie van join gebruiken we één van de mogelijke wijzen om een binaire boom te doorlopen. In ons geval hebben we gekozen voor de preorder methode; we hadden ook inorder of postorder kunnen gebruiken. De inorder methode heeft echter als bezwaar dat de boom t dan snel uit balans raakt. 2.9 Verwijderen van een knoop uit een boom Het verwijderen van een element uit een boom is minder eenvoudig dan het toevoegen. Merk op, dat toevoeging altijd plaatsvindt aan de bladeren van de boom. Een element, dat moet worden verwijderd, hoeft echter niet een blad te zijn. Het kan zich ook ergens middenin bevinden. We onderscheiden een drietal gevallen: 1. Het te verwijderen element heeft geen opvolgers: (left == null) && (right == null) 2. Het te verwijderen element heeft precies één opvolger: (left == null)!= (right == null) Met!= implementeren we de exclusief of (XOR), waarbij A!= B betekent dat A is waar of B is waar maar niet beiden. 3. Het te verwijderen element heeft twee opvolgers: (left!= null) && (right!= null) Het eerste geval is het eenvoudigst. De verwijzing wordt leeg gemaakt: result = null; en het element is verdwenen. In het tweede geval kunnen result laten wijzen naar de niet lege subboom, dus: if (right == null) 11
12 result = left; result = right; (Vergelijk met het verwijderen van een element uit een lineaire lijst.) Het derde geval is zoals gezegd lastiger. Omdat één referentie onmogelijk naar twee elementen tegelijk kan wijzen; result zou nu zowel naar left als right moeten gaan wijzen. We moeten van de twee resterende subbomen weer één boom maken. Bij dit proces moeten we ervoor zorgen dat de ordeningsrelatie tussen de knopen gehandhaafd blijft. Het gemakkelijkste gaat dit als we uitgaan van één van de twee subbomen; dientengevolge zijn er twee mogelijke oplossingen: we kiezen voor de linker subboom en hangen de rechter subboom onder de meest rechtse knoop of we kiezen voor de rechter subboom en hangen de linker subboom onder de meest linkse knoop. De eerste variant leidt tot de code: p = left; while (p.right!= null ) p=p.right; p.right := right; return left; We smeden dit alles aaneen tot één method: public TreeNode removeroot() // Verwijder het root element uit een boom TreeNode p; if (left == null) if (right == null) return null; return tree^.right; if (right == null) return left; 12
13 p = left; while (p.right!= null ) p=p.right; p.right := right; return left; In de practijk willen we echter een remove-methode in class SearchTree in staat is om een node met een bepaalde inhoud te verwijderen, als die bestaat. We moeten dus een verwijzing opzoeken naar de betreffende node. Die kunnen we dan beschouwen als de root van zijn eigen subboom, en vervangen de verwijzing naar de subboom door die naar de subboom minus de wortel. In class TreeNode krijgen we dan een removenode die er als volgt uit ziet: public boolean removenode(object item) if ( info.compareto(item) > 0 ) // item.key < root.key if ( left == null ) return false; // no item removed if (left.info.compareto(item) == 0) left = left.removeroot(); return true; return left.removenode(item); // remove from left tree // item.key >= root.key if ( right == null ) return false; // no item removed 13
14 if (right.info.compareto(item) == 0) right = right.removeroot(); return true; return right.removenode(item); // remove from left tree Tot slot moet binnen de class SearchTree een method remove gemaakt worden die drie situaties aan moet kunnen: de boom is leeg: dan geven we als return-waarde false. het root-element is het gezochte element: dan roep je de removeroot method van root aan. in alle overige gevallen moet de removenode method van root aangeroepen worden We krijgen dan: public boolean remove(object target) if (isempty()) return false; if (root.info.compareto(target)==0) root = root.removeroot(); return false; return root.removenode(target); Tot slot nog een methode die de som van elementen van een boom gevuld met Integers berekent. Weer is de som natuurlijk te schrijven als de som van de linker sub-boom, plus die van de rechter, plus de waarde van het huidige element. Wel moeten we controleren of de sub-bomen leeg zijn. In TreeNode hebben we dan: 14
15 public int sumint() int sum = ((Number)info).intValue(); if (left!= null) sum += left.sumint(); if (right!= null) sum += right.sumint(); return sum; Let op dat we eerst info casten naar een Number. En alternatief is: public int sumint() return (left!= null? left.sumint() : 0 ) + (right!= null? right.sumint() : 0 ) + ((Number)info).intValue(); Dit is compacter, maar je vindt het misschien minder leesbaar. Gebruik in dat geval de eerste aanpak. In SearchTree hebben we dan de method: public int sumint() if (isempty()) return 0; return root.sumint(); 15
16 2.10 Practicum 2 Week 4: Bomen Opgave 1 (SearchTree) Opgavenaam: SearchTree In te leveren file: SearchTree.java In deze opgave gaan we een aantal methods maken die binaire zoekbomen manipuleren. We plaatsen deze methods in een class SearchTree, die grotendeels beschikbaar staat in directory ~csg112/java/practicum2. Let op dat je in iedere opgave zowel in de private class TreeNode, als in SearchTree zelf iets moet veranderen. In dezelfde directory staat ook een file met de class TreeTest waarin een main methode staat die de door jullie gemaakte methods test. Ook staan er drie test files namen.txt, kruiden.txt en namensort.txt. Deze kun je als parameter meegeven bij aanroep van TreeTest. 1. Construeer een method int size() die het aantal elementen in een binaire zoekboom oplevert ZONDER dat de class SearchTree intern extra administratie gebruikt (deze opdracht wordt namelijk bijzonder flauw als je het aantal nodes intern in de class bij laat houden). 2. Construeer methods Object first() en Object last() die het kleinste resp. grootste element van een binaire zoekboom opleveren. 3. Construeer een method int depth() die de diepte van een een binaire zoekboom bepaald. De diepte is de maximale afstand tot de wortel van enige knoop. Voor een lege boom geldt derhalve depth = Construeer een method String tostring() die alle elementen in een boom gesorteerd in een string zet, gescheiden door end-of-line characters ( \n ). Stel je hebt in de nodes van de boom de volgende strings: Nootmuskaat, Geelwortel, Dragon, Jeneverbes, Salie, Peterselie, Waterkers, dan moet de uitvoer van tostring() zijn: Dragon Geelwortel Jeneverbes Nootmuskaat Peterselie Salie Waterkers Als je alles goed hebt gedaan, en je TreeTest en SearchTree hebt vertaald, dan levert het commando java TreeTest kruiden.txt 16
17 als uitvoer Aantal elementen : 7 Diepte Boom : 3 Theoretisch optimum : 3.0 Eerste element : Dragon Laatste element : Waterkers Gesorteerde lijst : Dragon Geelwortel Jeneverbes Nootmuskaat Peterselie Salie Waterkers Vergelijk ook even de output bij gebruik van namen.txt en namensort.txt. Het bovenste stukje van de uitvoer moet eruit zien als: Aantal elementen : 31 Diepte Boom : 5 Theoretisch optimum : 5.0 Eerste element : Allard Laatste element : Zef Gesorteerde lijst :... bij namen.txt, en bij namensort.txt krijg je: Aantal elementen : 31 Diepte Boom : 31 Theoretisch optimum : 5.0 Eerste element : Allard Laatste element : Zef Gesorteerde lijst : 17
18 ... Opgave 2 (SpeedTest) Opgavenaam: SpeedTest In te leveren file: SpeedTest.txt In deze opgave verwachten we niet dat je een programma instuurt, maar dat je een kort textfile met je bevindingen instuurt. Ook als de vorige opgave niet is gelukt, is het mogelijk deze te doen. We gebruiken nl. alleen de constructor en add methods uit SearchTree. De class SearchTree implementeerd een groot aantal methods van de standaard class TreeSet. Zoek in de Java documentatie de specificatie van deze class op. Let op dat men het heeft over een red-black balanced tree implementatie. In het file SpeedTest.java in dezelfde directory als SearchTree wordt de snelheid van het toevoegen van N elementen van class Integer aan de boom getest. Vertaal class SpeedTest, en run het met de volgende commando s: java SpeedTest 5000 java SpeedTest java SpeedTest java SpeedTest Heb geduld, het duurt best lang. Vervang nu in SpeedTest alle verwijzingen naar class SearchTree door TreeSet. Vertaal SpeedTest opnieuw, en run de commando s weer. Maak een tabel met de tijden als functie van N, voor beide tree-classes. Verklaar het verschil. HINT: let op de volgorde van invoegen. Geef aan de hand van de tijden van de SearchTree class een schatting van de complexiteit in O-notatie (let op hoe de tijd veranderd bij verdubbeling van N). 18
Java Programma structuur
Java Programma structuur public class Bla // div. statements public static void main(string argv[]) // meer spul Voortgezet Prog. voor KI, week 4:11 november 2002 1 Lijsten Voorbeelden 2, 3, 5, 7, 13 Jan,
Nadere informatieDatastructuren; (Zoek)bomen
Datastructuren; (Zoek)bomen Bomen, zoekbomen, gebalanceerde zoekbomen José Lagerberg FNWI, UvA José Lagerberg (FNWI, UvA) Datastructuren; (Zoek)bomen 1 / 50 Bomen Traversal van bomen Datastructuur van
Nadere informatieTree traversal. Bomen zijn overal. Ferd van Odenhoven. 15 november 2011
15 november 2011 Tree traversal Ferd van Odenhoven Fontys Hogeschool voor Techniek en Logistiek Venlo Software Engineering 15 november 2011 ODE/FHTBM Tree traversal 15 november 2011 1/22 1 ODE/FHTBM Tree
Nadere informatieElementary Data Structures 3
Elementary Data Structures 3 Ferd van Odenhoven Fontys Hogeschool voor Techniek en Logistiek Venlo Software Engineering 29 september 2014 ODE/FHTBM Elementary Data Structures 3 29 september 2014 1/14 Meer
Nadere informatieDatastructuren en algoritmen voor CKI
Datastructuren en algoritmen voor CKI Jeroen Bransen 1 9 oktober 2015 1 met dank aan Hans Bodlaender en Gerard Tel Zoekbomen Binaire boom Bestaat uit knopen Beginknoop is de wortel (root) Elke knoop heeft
Nadere informatieVoorbeeldtentamen Inleiding programmeren (IN1608WI), Oktober 2003, , Technische Universiteit Delft, Faculteit EWI, Afdeling 2.
Voorbeeldtentamen Inleiding programmeren (IN1608WI), Oktober 2003, 14.00-15.30, Technische Universiteit Delft, Faculteit EWI, Afdeling 2. Dit tentamen bestaat uit twee delen. Deel 1 (14.00-14.45, gesloten
Nadere informatieDatastructuren: stapels, rijen en binaire bomen
Programmeermethoden Datastructuren: stapels, rijen en binaire bomen week 12: 23 27 november 2015 www.liacs.leidenuniv.nl/ kosterswa/pm/ 1 Inleiding In de informatica worden Abstracte DataTypen (ADT s)
Nadere informatiepublic boolean equaldates() post: returns true iff there if the list contains at least two BirthDay objects with the same daynumber
Tentamen TI1310 Datastructuren en Algoritmen, 15 april 2011, 9.00-12.00 TU Delft, Faculteit EWI, Basiseenheid Software Engineering Bij het tentamen mag alleen de boeken van Goodrich en Tamassia worden
Nadere informatieHoofdstuk 3. Week 5: Sorteren. 3.1 Inleiding
Hoofdstuk 3 Week 5: Sorteren 3.1 Inleiding Zoals al bleek in college 1 kunnen zoekalgoritmen veel sneller worden uitgevoerd, indien we weten dat de elementen in de lijst, waarin wordt gezocht, geordend
Nadere informatieTree traversal. Ferd van Odenhoven. 15 november Fontys Hogeschool voor Techniek en Logistiek Venlo Software Engineering. Doorlopen van bomen
Tree traversal Ferd van Odenhoven Fontys Hogeschool voor Techniek en Logistiek Venlo Software Engineering 15 november 2011 ODE/FHTBM Tree traversal 15 november 2011 1/22 1 ODE/FHTBM Tree traversal 15 november
Nadere informatieAlgoritmiek. 15 februari Grafen en bomen
Algoritmiek 15 februari 2019 Grafen en bomen 1 Grafen (herhaling) Een graaf G wordt gedefinieerd als een paar (V,E), waarbij V een eindige verzameling is van knopen (vertices) en E een verzameling van
Nadere informatieOpgaven Zoekbomen Datastructuren, 20 juni 2018, Werkgroep.
Opgaven Zoekbomen Datastructuren, 20 juni 2018, Werkgroep. Gebruik deze opgaven, naast die uit het boek, om de stof te oefenen op het werkcollege. Cijfer: Op een toets krijg je meestal zes tot acht opgaven.
Nadere informatieOpgaven Zoekbomen Datastructuren, 15 juni 2016, Werkgroep.
Opgaven Zoekbomen Datastructuren, 15 juni 2016, Werkgroep. Gebruik deze opgaven, naast die uit het boek, om de stof te oefenen op het werkcollege. Cijfer: Op een toets krijg je meestal zes tot acht opgaven.
Nadere informatierecursie Hoofdstuk 5 Studeeraanwijzingen De studielast van deze leereenheid bedraagt circa 6 uur. Terminologie
Hoofdstuk 5 Recursion I N T R O D U C T I E Veel methoden die we op een datastructuur aan kunnen roepen, zullen op een recursieve wijze geïmplementeerd worden. Recursie is een techniek waarbij een vraagstuk
Nadere informatieRecursion. Introductie 37. Leerkern 37. Terugkoppeling 40. Uitwerking van de opgaven 40
Recursion Introductie 37 Leerkern 37 5.1 Foundations of recursion 37 5.2 Recursive analysis 37 5.3 Applications of recursion 38 Terugkoppeling 40 Uitwerking van de opgaven 40 Hoofdstuk 5 Recursion I N
Nadere informatie5.4.2 a. Neen: dit lukt alléén met 1, 3, 7 enzovoort. b. Ja: dit lukt met elk aantal knopen! Bijvoorbeeld de volgende boom: 1
c. het langste gerichte pad: 4 2 3 met lengte twee. d. het langste on -gerichte pad is oneindig lang: je mag bijvoorbeeld voortdurend tussen twee knopen heen en weer wandelen. e. ja: elke knoop heeft maximaal
Nadere informatieHoofdstuk 6. Geordende binaire bomen
Hoofdstuk 6 Geordende binaire bomen Eerder bespraken we hoe gelinkte lijsten een zeer flexibele structuur geven. Het zoeken in een gelinkte lijst was echter niet optimaal, aangezien je enkel de lijst van
Nadere informatieTentamen Programmeren in C (EE1400)
TU Delft Tentamen Programmeren in C (EE1400) 5 april 2012, 9.00 12.00 Faculteit EWI - Zet op elk antwoordblad je naam en studienummer. - Beantwoord alle vragen zo nauwkeurig mogelijk. - Wanneer C code
Nadere informatieTweede college algoritmiek. 12 februari Grafen en bomen
College 2 Tweede college algoritmiek 12 februari 2016 Grafen en bomen 1 Grafen (herhaling) Een graaf G wordt gedefinieerd als een paar (V,E), waarbij V een eindige verzameling is van knopen (vertices)
Nadere informatieModelleren en Programmeren
Modelleren en Programmeren Jeroen Bransen 13 december 2013 Terugblik Fibonacci public class Fibonacci { public static void main(string[] args) { // Print het vijfde Fibonaccigetal System.out.println(fib(5));
Nadere informatieInleiding Programmeren 2
Inleiding Programmeren 2 Gertjan van Noord November 28, 2016 Stof week 3 nogmaals Zelle hoofdstuk 8 en recursie Brookshear hoofdstuk 5: Algoritmes Datastructuren: tuples Een geheel andere manier om te
Nadere informatieModelleren en Programmeren
Modelleren en Programmeren Jeroen Bransen 6 december 2013 Terugblik Programma en geheugen Opdrachten Variabelen Methoden Objecten Klasse Programma en geheugen Opdrachten Variabelen zijn gegroepeerd in
Nadere informatieInleiding Programmeren 2
Inleiding Programmeren 2 Gertjan van Noord November 26, 2018 Stof week 3 nogmaals Zelle hoofdstuk 8 en recursie Brookshear hoofdstuk 5: Algoritmes Datastructuren: tuples Een geheel andere manier om te
Nadere informatieUitwerking tentamen Algoritmiek 9 juni :00 17:00
Uitwerking tentamen Algoritmiek 9 juni 2015 14:00 17:00 1. Clobber a. Toestanden: m x n bord met in elk hokje een O, een X of een -. Hierbij is het aantal O gelijk aan het aantal X of er is hooguit één
Nadere informatieModelleren en Programmeren
Modelleren en Programmeren Jeroen Bransen 11 december 2015 Ingebouwde datastructuren Meer boomstructuren Access specifiers Gebruikersinvoer Codestijl Packages SAT-solver Ingebouwde datastructuren Ingebouwde
Nadere informatieTentamen Imperatief en Object-georiënteerd programmeren in Java voor CKI
Tentamen Imperatief en Object-georiënteerd programmeren in Java voor CKI Vrijdag 22 januari 2010 Toelichting Dit is een open boek tentamen. Communicatie en het gebruik van hulpmiddelen zijn niet toegestaan.
Nadere informatieDatatypes Een datatype is de sort van van een waarde van een variabele, veel gebruikte datatypes zijn: String, int, Bool, char en double.
Algemeen C# Variabele Een variabele is een willekeurige waarde die word opgeslagen. Een variabele heeft altijd een datetype ( De soort waarde die een variabele bevat). Datatypes Een datatype is de sort
Nadere informatieBomen. 8.8 ongerichte bomen 9.4 gerichte bomen ch 10. binaire bomen. deel 2. Tiende college
10 Bomen deel 2 Tiende college 8.8 ongerichte bomen 9.4 gerichte bomen ch 10. binaire bomen 1 arboretum ongericht 8.8 tree graphs 9.4 rooted trees ch.10 binary trees 2 gericht geordend links/rechts bomen
Nadere informatieStacks and queues. Introductie 45. Leerkern 45. Terugkoppeling 49. Uitwerking van de opgaven 49
Stacks and queues Introductie 45 Leerkern 45 6.1 Stacks 45 6.2 Queues 47 6.3 Double-ended queues 48 Terugkoppeling 49 Uitwerking van de opgaven 49 Bijlage: Diagrammen belangrijkste interfaces en klassen
Nadere informatieProgrammeren in C++ Efficiënte zoekfunctie in een boek
Examen Software Ontwikkeling I 2e Bachelor Informatica Faculteit Wetenschappen Academiejaar 2010-2011 21 januari, 2011 **BELANGRIJK** 1. Lees eerst de volledige opgave (inclusief de hints/opmerkingen)!
Nadere informatieEen gelinkte lijst in C#
Een gelinkte lijst in C# In deze tutorial ga demonstreren hoe je een gelinkte lijst kan opstellen in C#. We gaan een klasse schrijven, die een gelijkaardige functionaliteit heeft als een ArrayList, namelijk
Nadere informatieBomen. 8.8 ongerichte bomen 9.4 gerichte bomen ch 10. binaire bomen
10 Bomen 8.8 ongerichte bomen 9.4 gerichte bomen ch 10. binaire bomen 1 Baarn Hilversum Soestdijk Den Dolder voorbeelden route boom beslisboom Amersfoort Soestduinen + 5 * + 5.1 5.2 5.3 5.4 2 3 * * 2 5.3.1
Nadere informatieTentamen Programmeren in C (EE1400)
TU Delft Tentamen Programmeren in C (EE1400) 3 feb. 2012, 9.00 12.00 Faculteit EWI - Zet op elk antwoordblad je naam en studienummer. - Beantwoord alle vragen zo nauwkeurig mogelijk. - Wanneer C code gevraagd
Nadere informatieUitwerking tentamen Algoritmiek 10 juni :00 13:00
Uitwerking tentamen Algoritmiek 10 juni 2014 10:00 13:00 1. Dominono s a. Toestanden: n x n bord met in elk hokje een O, een X of een -. Hierbij is het aantal X gelijk aan het aantal O of hooguit één hoger.
Nadere informatieDatastructuren Programmeeropdracht 3: Expressies. 1 Expressies. Deadline. Dinsdag 8 december 23:59.
Datastructuren 2015 Programmeeropdracht 3: Expressies Deadline. Dinsdag 8 december 23:59. Inleiding. Deze opdracht is losjes gebaseerd op Opdracht 5.13.2 in het boek van Drozdek. U wordt gevraagd expressies
Nadere informatieDatastructuren en Algoritmen voor CKI
Ω /texmf/tex/latex/uubeamer.sty-h@@k 00 /texmf/tex/latex/uubeamer.sty Datastructuren en Algoritmen voor CKI Vincent van Oostrom Clemens Grabmayer Afdeling Wijsbegeerte Hoorcollege 5 16 februari 2009 Waar
Nadere informatieTentamen Object Georiënteerd Programmeren TI1200 30 januari 2013, 9.00-12.00 Afdeling SCT, Faculteit EWI, TU Delft
Tentamen Object Georiënteerd Programmeren TI1200 30 januari 2013, 9.00-12.00 Afdeling SCT, Faculteit EWI, TU Delft Bij dit tentamen mag je geen gebruik maken van hulpmiddelen zoals boek of slides. Dit
Nadere informatieDatastructuren: stapels, rijen en binaire bomen
Programmeermethoden : stapels, rijen en binaire bomen Walter Kosters week 12: 26 30 november 2018 www.liacs.leidenuniv.nl/ kosterswa/pm/ 1 en Vierde programmeeropgave Othello programmeren we als volgt:
Nadere informatieProgrammeren in Java les 3
4 september 2015 Deze les korte herhaling vorige week loops methodes Variabelen Soorten variabelen in Java: integer: een geheel getal, bijv. 1,2,3,4 float: een gebroken getal, bijv. 3.1415 double: een
Nadere informatieZelftest Inleiding Programmeren
Zelftest Inleiding Programmeren Document: n0824test.fm 22/01/2013 ABIS Training & Consulting P.O. Box 220 B-3000 Leuven Belgium TRAINING & CONSULTING INLEIDING BIJ DE ZELFTEST INLEIDING PROGRAMMEREN Deze
Nadere informatieElfde college algoritmiek. 18 mei Algoritme van Dijkstra, Heap, Heapify & Heapsort
Algoritmiek 018/Algoritme van Dijkstra Elfde college algoritmiek 18 mei 018 Algoritme van Dijkstra, Heap, Heapify & Heapsort 1 Algoritmiek 018/Algoritme van Dijkstra Uit college 10: Voorb. -1- A B C D
Nadere informatieHOOFDSTUK 3. Imperatief programmeren. 3.1 Stapsgewijs programmeren. 3.2 If Then Else. Module 4 Programmeren
HOOFDSTUK 3 3.1 Stapsgewijs programmeren De programmeertalen die tot nu toe genoemd zijn, zijn imperatieve of procedurele programmeertalen. is het stapsgewijs in code omschrijven wat een programma moet
Nadere informatieVoortgezet Prog. voor KI
Voortgezet Prog. voor KI Docent: Michael Wilkinson IWI 142 tel. 050-3638140 (secr. 3633939) Frank Brokken RC 352 tel. 050-3633688 Voorkennis: Inleiding Programmeren voor KI (nieuwe stijl) Stof: Practicum
Nadere informatieDatastructuren en algoritmen voor CKI
Datastructuren en algoritmen voor CKI Jeroen Bransen 1 14 oktober 2015 1 met dank aan Hans Bodlaender en Gerard Tel Willekeurig gebouwde zoekbomen Willekeurig gebouwde zoekbomen Hoogte van zoekboom met
Nadere informatieTentamen in2705 Software Engineering
Tentamen in2705 Software Engineering Voorbeeld (bijna tweemaal te groot) U mag meenemen naar dit tentamen: Lethbridge, afdrukken PPT slides, afdrukken handouts. 1. De TU wil een nieuw systeem ontwikkelen
Nadere informatiePracticumopgave 3: SAT-solver
Practicumopgave 3: SAT-solver Modelleren en Programmeren 2015/2016 Deadline: donderdag 7 januari 2016, 23:59 Introductie In het vak Inleiding Logica is onder andere de propositielogica behandeld. Veel
Nadere informatieAanvullende toets Gameprogrammeren (INFOB1GP) Woensdag 24 december 2014, uur
Aanvullende toets Gameprogrammeren (INFOB1GP) Woensdag 24 december 2014, 13.30-15.30 uur Naam: Studentnummer: Het tentamen bestaat uit 4 opgaven. Opgaven 1 levert 8 punten op, opgave 2 levert 12 punten
Nadere informatieDynamisch Programmeren. Het Rugzakprobleem
INLEIDING Dynamisch Programmeren 1 Dynamisch Programmeren Section Page Inleiding................................................. 1 1 Oplossing................................................ 2 2 Subprobleem.............................................
Nadere informatieis eigenlijk overbodig!
Array Declaratie Creatie Opvragen Wijzigen Lengte is eigenlijk overbodig! array: oject dat een rij waarden bevat, met speciale notaties Invoegen Achtervoegen String [ ] a; a = new String[10]; a[5] a[5]
Nadere informatieProgrammeermethoden. Recursie. Walter Kosters. week 11: november kosterswa/pm/
Programmeermethoden Recursie Walter Kosters week 11: 20 24 november 2017 www.liacs.leidenuniv.nl/ kosterswa/pm/ 1 Vierde programmeeropgave 1 De Grote getallen programmeren we als volgt: week 1: pointerpracticum,
Nadere informatieUniversiteit van Amsterdam FNWI. Voorbeeld van tussentoets Inleiding programmeren
Universiteit van Amsterdam FNWI Voorbeeld van tussentoets Inleiding programmeren Opgave 1: Wat is de uitvoer van dit programma? public class Opgave { static int i = 0 ; static int j = 1 ; int i = 1 ; int
Nadere informatieProgrammeermethoden. Recursie. week 11: november kosterswa/pm/
Programmeermethoden Recursie week 11: 21 25 november 2016 www.liacs.leidenuniv.nl/ kosterswa/pm/ 1 Pointers Derde programmeeropgave 1 Het spel Gomoku programmeren we als volgt: week 1: pointerpracticum,
Nadere informatieTECHNISCHE UNrVERSITElT DELFT Faculteit Elektrotechniek, Wiskunde en Informatica
TECHNISCHE UNrVERSITElT DELFT Faculteit Elektrotechniek, Wiskunde en Informatica TWl(0)9O Inleiding Programmeren Tentamen 16 maart 2017, 9:00-12:00 uur Normering: Opgave 1 t/m 3 ieder 6 punten. Score:
Nadere informatieAchtste college algoritmiek. 12 april Verdeel en Heers. Dynamisch Programmeren
Achtste college algoritmiek 12 april 2019 Verdeel en Heers Dynamisch Programmeren 1 Uit college 7: Partitie Partitie Partitie(A[l r]) :: // partitioneert een (sub)array, met A[l] als spil (pivot) p :=
Nadere informatieHet minimale aantal sleutels op niveau h is derhalve
1 (a) In een B-boom van orde m bevat de wortel minimaal 1 sleutel en maximaal m 1 sleutels De andere knopen bevatten minimaal m 1 sleutels en maximaal m 1 sleutels (b) In een B-boom van orde 5 bevat elke
Nadere informatieStacks and queues. Hoofdstuk 6
Hoofdstuk 6 Stacks and queues I N T R O D U C T I E In dit hoofdstuk worden drie datastructuren stack, queue en deque behandeld. Om deze datastructuren te implementeren, worden onder andere arrays en linked
Nadere informatieTentamen Imperatief Programmeren
Tentamen Imperatief Programmeren Maandag 22 oktober 2001 Toelichting Dit is een open boek tentamen, d.w.z. het cursusboek mag gebruikt worden. N.B.: Het tentamen is individueel: voor het maken van de opgaven
Nadere informatieDatastructuren. Analyse van algoritmen. José Lagerberg. FNWI, UvA. José Lagerberg (FNWI, UvA) Datastructuren 1 / 46
Datastructuren Analyse van algoritmen José Lagerberg FNWI, UvA José Lagerberg (FNWI, UvA) Datastructuren 1 / 46 Datastructuren en Algoritmen Datastructuren, 6 ECTS eerstejaars Bachelor INF Datastructuren,
Nadere informatieVierde college complexiteit. 14 februari Beslissingsbomen
College 4 Vierde college complexiteit 14 februari 2017 Restant zoeken Beslissingsbomen 1 Binair zoeken Links := 1; Rechts := n; while Links Rechts do Midden := Links + Rechts 2 ; if X = A[Midden] then
Nadere informatieJavascript oefenblad 1
Leer de basis van Javascript. Javascript oefenblad 1 Niels van Velzen Javascript oefenblad 1 Pagina 2 Inleiding Javascript is niet altijd even makkelijk. Vooral aan het begin is het even wennen hoe de
Nadere informatieUitwerking tentamen Algoritmiek 9 juli :00 13:00
Uitwerking tentamen Algoritmiek 9 juli 0 0:00 :00. (N,M)-game a. Toestanden: Een geheel getal g, waarvoor geldt g N én wie er aan de beurt is (Tristan of Isolde) b. c. Acties: Het noemen van een geheel
Nadere informatieInformatica: C# WPO 11
Informatica: C# WPO 11 1. Inhoud Pass by reference (ref, out), recursie, code opdelen in verschillende codebestanden 2. Oefeningen Demo 1: Swapfunctie Demo 2: TryParse(int) Demo 3: Recursion Tree Demo
Nadere informatieTENTAMEN Programmeren 1 VOORBEELDUITWERKING
TENTAMEN Programmeren 1 vakcode: 213500 datum: 10 juli 2004 tijd: 9:00-12:30 uur VOORBEELDUITWERKING Algemeen Bij dit tentamen mag gebruik worden gemaakt van het boek van Niño/Hosch, en van de handleiding
Nadere informatieTweede Toets Datastructuren 29 juni 2016, , Educ-Γ.
Tweede Toets Datastructuren 29 juni 2016, 13.30 15.30, Educ-Γ. Motiveer je antwoorden kort! Zet je mobiel uit. Stel geen vragen over deze toets; als je een vraag niet duidelijk vindt, schrijf dan op hoe
Nadere informatiepublic boolean egualdates() post: returns true i f f there i f the l i s t contains at least two BirthDay objects with the same daynumber
Tentamen TI1310 Datastructuren en Algoritmen, 15 april 2011, 9.00-12.00 TU Delft, Faculteit EWI, Basiseenheid Software Engineering Bij het tentamen mag alleen de boeken van Goodrich en Tamassia worden
Nadere informatieEE1400: Programmeren in C BSc. EE, 1e jaar, , 4e college
EE1400: Programmeren in C BSc. EE, 1e jaar, 2012-2013, 4e college Arjan van Genderen, Computer Engineering 11-12-2012 Delft University of Technology Challenge the future Mededelingen Voortgangstoets: Woensdagmiddag
Nadere informatieAls een PSD selecties bevat, deelt de lijn van het programma zich op met de verschillende antwoorden op het vraagstuk.
HOOFDSTUK 3 3.1 Stapsgewijs programmeren In de vorige hoofdstukken zijn programmeertalen beschreven die imperatief zijn. is het stapsgewijs in code omschrijven wat een programma moet doen, net als een
Nadere informatieModelleren en Programmeren
Modelleren en Programmeren Jeroen Bransen 27 november 2015 Recursie Objecten Constructors Aanpassen variabelen this keyword Recursie Recursie Recursieve functie roept zichzelf (direct of indirect) aan
Nadere informatievoegtoe: eerst methode bevat gebruiken, alleen toevoegen als bevat() false is
PROEF-Tentamen Inleiding programmeren (IN1608WI), X januari 2010, 9.00-11.00, Technische Universiteit Delft, Faculteit EWI, Afdeling 2. Open boek tentamen: bij het tentamen mag alleen gebruik worden gemaakt
Nadere informatieDIAGNOSTISCHE TOETS Softwaresystemen UITWERKING
DIAGNOSTISCHE TOETS Softwaresystemen datum: Donderdag van Week 7 UITWERKING Deze diagnostische toets bevat vragen over excepties en concurrency. Beantwoord de vragen zo goed mogelijk in 30 minuten Bespreek
Nadere informatieOver binaire beslissingsdiagrammen naar Donald E. Knuth s The Art of Computer Programming, Volume 4
Over binaire beslissingsdiagrammen naar Donald E. Knuth s The Art of Computer Programming, Volume 4 Jonathan K. Vis 1 Inleiding (blz. 70 72) In dit essay behandelen we bladzijden 70 75 van Donald E. Knuth
Nadere informatiedefinities recursieve datastructuren college 13 plaatjes soorten Graph = ( V, E ) V vertices, nodes, objecten, knopen, punten
recursieve datastructuren college graphs definities Graph = ( V, E ) V vertices, nodes, objecten, knopen, punten E edges, arcs, kanten, pijlen, lijnen verbinding tussen knopen Voorbeelden steden en verbindingswegen
Nadere informatieTentamen Objectgeorienteerd Programmeren TI februari Afdeling ST Faculteit EWI TU Delft
I ' Tentamen Objectgeorienteerd Programmeren TI 1200 1 februari 2012 9.00-12.00 Afdeling ST Faculteit EWI TU Delft Bij dit tentamen mag je geen gebruik maken van hulpmiddelen zoals boek of slides. Dit
Nadere informatie2 Recurrente betrekkingen
WIS2 1 2 Recurrente betrekkingen 2.1 Fibonacci De getallen van Fibonacci Fibonacci (= Leonardo van Pisa), 1202: Bereken het aantal paren konijnen na één jaar, als 1. er na 1 maand 1 paar pasgeboren konijnen
Nadere informatieProgrammeermethoden NA. Week 6: Lijsten
Programmeermethoden NA Week 6: Lijsten Kristian Rietveld http://liacs.leidenuniv.nl/~rietveldkfd/courses/prna2016/ Getal opbouwen Stel je leest losse karakters (waaronder cijfers) en je moet daar een getal
Nadere informatieZevende college algoritmiek. 24 maart Verdeel en Heers
Zevende college algoritmiek 24 maart 2016 Verdeel en Heers 1 Verdeel en heers 1 Divide and Conquer 1. Verdeel een instantie van het probleem in twee (of meer) kleinere instanties 2. Los de kleinere instanties
Nadere informatieExamen Programmeren 2e Bachelor Elektrotechniek en Computerwetenschappen Faculteit Ingenieurswetenschappen Academiejaar juni, 2010
Examen Programmeren 2e Bachelor Elektrotechniek en Computerwetenschappen Faculteit Ingenieurswetenschappen Academiejaar 2009-2010 16 juni, 2010 **BELANGRIJK** 1. Lees eerst de volledige opgave (inclusief
Nadere informatieTentamen Object Georiënteerd Programmeren TI1206 29 oktober 2014, 9.00-11.00 Afdeling SCT, Faculteit EWI, TU Delft
Tentamen Object Georiënteerd Programmeren TI1206 29 oktober 2014, 9.00-11.00 Afdeling SCT, Faculteit EWI, TU Delft Bij dit tentamen mag je geen gebruik maken van hulpmiddelen zoals boek of slides. Digitale
Nadere informatieAddendum bij hoofdstuk 5 Generieke implementatie van de zoekalgoritmen
Addendum bij hoofdstuk 5 Generieke implementatie van de zoekalgoritmen De implementatie wordt kort besproken in 5.2.6 1. Programmatie Zoekalgoritme Definitie van boom: we hebben geen binaire boom met exact
Nadere informatieAlgoritmen, Datastructuren en Complexiteit ( en ) Uitwerkingen
Universiteit Twente 2009-2010/2 Afdeling Informatica, Faculteit EWI Tentamen dinsdag 19 januari 2010, 8.45-12.15 Algoritmen, Datastructuren en Complexiteit (214020 en 214025) Uitwerkingen Bij dit tentamen
Nadere informatieIMP Uitwerking week 13
IMP Uitwerking week 13 Opgave 1 Nee. Anders moet bijvoorbeeld een venster applicatie een subklasse zijn van zowel Frame en WindowListener. Als de applicatie ook een button of een menu heeft, dan moet het
Nadere informatieTweede Toets Datastructuren 28 juni 2017, , Educ-β.
Tweede Toets Datastructuren 28 juni 2017, 13.30 15.30, Educ-β. Motiveer je antwoorden kort! Stel geen vragen over deze toets; als je een vraag niet duidelijk vindt, schrijf dan op hoe je de vraag interpreteert
Nadere informatieProgrammeermethoden NA
Programmeermethoden NA Week 6: Lijsten Kristian Rietveld http://liacs.leidenuniv.nl/~rietveldkfd/courses/prna/ Bij ons leer je de wereld kennen 1 Getal opbouwen Stel je leest losse karakters (waaronder
Nadere informatieExamen Datastructuren en Algoritmen II
Tweede bachelor Informatica Academiejaar 2012 2013, tweede zittijd Examen Datastructuren en Algoritmen II Naam :.............................................................................. Lees de hele
Nadere informatiehttp://www.liacs.nl/home/kosters/java/
sheets Programmeren 1 Java college 2, Walter Kosters De sheets zijn gebaseerd op de hoofdstukken 2 tot en met 6 van: D. Bell en M. Parr, Java voor studenten, Prentice Hall, 2002 http://www.liacs.nl/home/kosters/java/
Nadere informatieGegevens invullen in HOOFDLETTERS en LEESBAAR, aub. Belgische Olympiades in de Informatica (duur : maximum 1u15 )
OI 2010 Finale 12 Mei 2010 Gegevens invullen in HOOFDLETTERS en LEESBAAR, aub VOORNAAM :....................................................... NAAM :..............................................................
Nadere informatieAPPLICATIEBOUW 3E COLLEGE: OBJECT GEORIËNTEERD PROGRAMMEREN, METHODEN, PARAMETERS, SCOPE VAN VARIABELEN. Onderdeel van SmartProducts
APPLICATIEBOUW 3E COLLEGE: OBJECT GEORIËNTEERD PROGRAMMEREN, METHODEN, PARAMETERS, SCOPE VAN VARIABELEN Onderdeel van SmartProducts INHOUD COLLEGE 3 Scope van variabelen {3.9} Class ontwerpen en maken,
Nadere informatiesoftware constructie recursieve datastructuren college 15 5 stappen plan ontwerpen de software bestaat uiteindelijk uit datatypen functies
software constructie recursieve datastructuren college 15 software engineering highlights 1 de software bestaat uiteindelijk uit datatypen functies verbindingen geven gebruik aan main is de top van het
Nadere informatieIn BlueJ. Doe onderstaande met muis/menu s:
In BlueJ Doe onderstaande met muis/menu s: Download en unzip het bestand sklok-run.zip en open het in BlueJ Maak een Schaakklok-object Voer herstart() uit voor dit object Vraag de resterende tijd op voor
Nadere informatieUitgebreide uitwerking Tentamen Complexiteit, mei 2007
Uitgebreide uitwerking Tentamen Complexiteit, mei 007 Opgave. a. Een beslissingsboom beschrijft de werking van het betreffende algoritme (gebaseerd op arrayvergelijkingen) op elke mogelijke invoer. In
Nadere informatieCollege Introductie
College 2016-2017 Introductie Doaitse Swierstra (Jeroen Bransen) Utrecht University September 13, 2016 Waarom is FP anders? in plaats van opdrachten die na elkaar moeten worden uitgevoerd, definiëren we
Nadere informatieDatastructuren en Algoritmen
Datastructuren en Algoritmen Tentamen Vrijdag 6 november 2015 13.30-16.30 Toelichting Bij dit tentamen mag je gebruik maken van een spiekbriefje van maximaal 2 kantjes. Verder mogen er geen hulpmiddelen
Nadere informatieUitwerking Aanvullend tentamen Imperatief programmeren Woensdag 24 december 2014, 13.30 15.30 uur
Uitwerking Aanvullend tentamen Imperatief programmeren Woensdag 24 december 2014, 13.30 15.30 uur 1. deze opgave telt voor 30% van het totaal. Schrijf een compleet programma, dat door de gebruiker vanaf
Nadere informatieTentamen Objectgeorienteerd Programmeren IN1205 Voorbeeld
Tentamen Objectgeorienteerd Programmeren IN1205 Voorbeeld Afdeling ST Faculteit EWI TU Delft Bij dit tentamen mag u gebruik maken van: Barnes, Object-Oriented Programming with Java en de Notitie Algoritmiek
Nadere informatieLineaire data structuren. Doorlopen van een lijst
Lineaire data structuren array: vast aantal data items die aaneensluitend gestockeerd zijn de elementen zijn bereikbaar via een index lijst: een aantal individuele elementen die met elkaar gelinkt zijn
Nadere informatieTwaalfde college algoritmiek. 13 mei Branch & Bound Heap, Heapsort & Heapify
Algoritmiek 2016/Branch & Bound Twaalfde college algoritmiek 13 mei 2016 Branch & Bound Heap, Heapsort & Heapify 1 Algoritmiek 2016/Branch & Bound TSP met Branch & Bound Mogelijke ondergrenzen voor de
Nadere informatieDatastructuren en algoritmen
Datastructuren en algoritmen Doelstelling Datastructures + algorithms = programs Boek van Niklaus Wirth: bedenker Pascal en Modula Datastructuur: structuur om informatie op te slaan Algoritme: voorschrift
Nadere informatieLab Webdesign: Javascript 3 maart 2008
H5: OPERATORS In dit hoofdstuk zullen we het hebben over de operators (of ook wel: operatoren) in JavaScript waarmee allerlei rekenkundige en logische bewerkingen kunnen worden uitgevoerd. Daarbij zullen
Nadere informatieZevende college algoritmiek. 23/24 maart Verdeel en Heers
Zevende college algoritmiek 23/24 maart 2017 Verdeel en Heers 1 Algoritmiek 2017/Backtracking Tweede Programmeeropdracht 0 1 2 3 0 1 2 3 4 1 2 3 4 5 2 Algoritmiek 2017/Backtracking Tweede Programmeeropdracht
Nadere informatie