software constructie recursieve datastructuren college 15 5 stappen plan ontwerpen de software bestaat uiteindelijk uit datatypen functies

Transcriptie

1 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 bouwwerk elementaire datatypen vormen de bodem alles daartussen gebruikt wat en wordt zelf gebruikt bij recursie is er een rondgaand pad hoe komen we aan dit bouwwerk? trail and error? begin met iets dat er op lijkt en ga debuggen? gebruik een ontwerp! 2 5 stappen plan 1. Probleemanalyse, specificatie 2. Ontwerp van algoritmen en datastructuren plaatjes, tekst, formule, algemeen geval 3. Reflectie zal het gaan werken zal het probleem opgelost worden 4. Implementeren pas hier code schrijven 5. Evaluatie testen om kwaliteit te bepalen werkt het in alle gevallen, verificatie is het probleem opgelost, validatie 3 ontwerpen dit is de essentiële en spannende stap plaatjes, formules, pseudo-code hoeft niet tot in het laatste detail dingen die 'zeker lukken' kun je overslaan layout van dialogen initialisatie van een rijtje vergeet dit uiteindelijk niet hoe meer ervaring, hoe minder details in ontwerp groot gevaar voor zelfoverschatting reflectie moet mogelijk zijn op basis van ontwerp voor grote projecten maak je soms een prototype hiervoor doorloop je dezelfde stappen! 4 1

2 implementeren ontwerp ligt klaar voor je begint top-down: van boven naar onder bottom-up incrementeel: bouw stukje bij beetje begin met een programma dat weinig kan maak het langzaam krachtiger test ieder gebouwd stukje meteen maak eerst de stukken waar twijfels over bestaan als herontwerp nodig is, is er weinig verloren problemen kun je maar beter snel kennen compleet ontwerp nodig om bouwwerk uiteindelijk af in een plaatje: software constructie incrementeel te kunnen maken 5 6 highlights programmeertaal aspecten recursieve datastructuren dynamic programming programma ontwerp taal implementatie graph algoritmen lineaire algebra abstractie 7 pointers behalve een type, waarde en naam hebben objecten een object-id iedere instantie van een type heeft een unieke id in C++ (en andere talen) is de id z'n adres dit idee is al ouder dan OO die adressen veranderen niet adressen kun je manipuleren als normale objecten in je programma: pointers afspraak NULL-pointer wijst nergens heen nuttig en nodig in veel programma's recursieve datastructuren je kunt er ook veel fouten mee maken 8 2

3 programmeertaal aspecten pointers T*, &x, NULL functies resultaat: void, T, T*, T& argumenten: T, T*, T&, T [] rijen, C-strings aanname: T* wijst altijd in rij T[] r[i] en *(r+i) zijn dan gelijk objecten zichtbaarheid (scope) levensduur altijd het huidige compound statement objecten gemaakt met new leven voor 'eeuwig' opruimen met delete 9 subklassen van iedere klasse kun je een subklasse maken deze kan extra attributen en methoden bevatten class sub : public hoofd { int extra; protected: int f ( ) { return extra+1; } }; hiding via private, public en protected herdefinitie voor virtual methoden overal waar je hoofd verwacht mag je sub gebruiken typeconversie van sub naar hoofd voor directe types dynamic binding via pointers en ref args (C& of C*) object-id: this pointer 10 dynamic binding recursieve datastructuren class hoofd {public: virtual int f ( ) { return 1; } }; class sub : public hoofd {public : int f ( ) { return 2; } }; geeft dus: int main ( ) 1, 2 { hoofd h; sub s; hoofd h2 = s; hoofd *hp = &s; cout << h2. f ( ) << ", " << hp -> f ( ) << endl; voorbeelden: lijst, gesorteerde lijst, queue, stack,.. boom, zoekboom,.. basis knoop is object of structuur met één element knoop bevat pointer(s) naar opvolger(s) null pointer: er is geen opvolger hierdoor kan dynamisch iedere grootte gemaakt worden gebruik aparte klasse om eigenschappen te bewaken zoekboom, queue, stack,.. list:

4 lijsten knoop heeft hooguit één opvolger voordeel boven rijen: altijd een element toe te voegen element ertussen of eruit kan altijd goedkoop O(1) nadeel element opzoeken is duurder: O(n) i.p.v. O(1) 13 lijst in C++ typedef class Knoop *Lijst; // Lijst is een pointer!! class Knoop { El kop; // het lijstelement, private Lijst staart; // recursie: pointer naar de volgende public: Knoop ( El hd, Lijst tl = Leeg ) : kop ( hd ), staart ( tl ) { } ~Knoop() { delete staart; } // destructor: ruim hele lijst op friend El& head ( Lijst ); // vrienden kennen private velden friend Lijst& tail ( Lijst ); }; El& head ( Lijst l ) { assert ( l!= Leeg ); // voorkom selectie uit lege lijst return l->kop; } 14 bomen implementatie als lijsten verschil: bomen hebben meer dan 1 opvolger gebruik: zoekbomen (gebalnceerde zoekbomen, AVL, Red-black) representatie van talen... gesorteerde datastructuren gebruikt om elementen efficiënt te vinden structuur actie element zoeken element toevoegen element verwijderen gesorteerde rij O ( log n ) O ( n ) O ( n ) gesorteerde lijst O ( n ) O ( 1 ) O ( 1 ) gebalanceerde zoekboom O ( log n ) O ( 1 ) O ( 1 ) 15 1) dit zijn bovengrenzen, soms kan het sneller 2) we gaan er bij toevoegen en verwijderen vanuit dat we de plaats weten 3) balanceren en gebalanceerd houden van de boom vergt extra werk 4) ongebalanceerde bomen gedragen zich als lijst 16 4

5 speciale zoekbomen houden zich dynamisch steeds in balans alle operaties in O(log N) AVL-bomen verschil in hoogte steeds hooguit 1 sla dit op in iedere knoop als knoop uit balans: herbalanceren (draaien) Red-Black trees wortel en bladeren zijn zwart alle paden hebben zelfde aantal zwarte knopen alle rode knopen hebben zwarte kinderen indien uit balans: draaien en/of kleuren B-bomen, 2/3 bomen, lijst/boom-manipulaties gebruiken altijd pointers aflopen is nooit een probleem pointer zelf of kopie van pointer zijn evengoed veranderen: zorg dat je geen kopie verandert pak pointer uit knoop tail ( l ) = tail ( tail ( l )); gebruik een reference argument in recursieve functie void f ( Lijst & l ) { l = tail ( l ); } gebruik pointer naar pointer Knoop ** p = &l; p = & (( *p ) -> next ); *p = ( *p ) -> next; 18 taal implementatie altijd opbreken in verschillende fasen scanner: maakt tokens van invoer gebruik reguliere definities voor syntax van tokens altijd simpel, nooit een moeilijke keuze parser: maakt syntaxboom van tokens maak een klasse hiërarchie die past bij de syntax boom interpreter: bepaalt waarde met deze syntaxboom syntaxboom blijft hetzelfde manipulatie: verander deze syntaxboom interpretatie semantiek geeft vertelt direct wat er moet gebeuren parser recursive descent: goede syntax nodig ( niet links recursief, LL(1) ) met LL(1) kun je direct zien welke regel past anders grote look ahead of backtracking nodig stop prioriteit van operatoren in de regels van de grammatica E -> E + T T // expressie T -> T * F F // term F -> ( E ) num // factor simpel en direct regels van parser volgen direct de grammatica bottom-up tabel met prioriteiten en stack nodig (bijna) alle parser generatoren maken zo'n shift reduce parser

6 dynamic programming idee: dubbel recursieve functies hebben vaak een vreselijke complexiteit, b.v. O(2 n ) als het aantal mogelijke argumenten beperkt is kunnen we een tabel maken met resultaten in plaats van opnieuw uitrekenen kunnen we nu waarden opzoeken in de tabel, O(1) voor N waarden en m argumenten hebben we O(N m ) waarden in de tabel maakt veel problemen doable edit distance,... lineaire algebra lineaire afbeeldingen in R n kunnen handig met een matrix vermenigvuldiging A ( B v ) = ( A B ) v schuiven is niet lineair, maar kan met vermenigvuldiging in R n+1 ga over op homogene coördinaten (voeg extra 0 toe) implementatie vergt vectoren en matrices van verschillende grootte dit kan prima met templates graph algoritmen veel problemen laten zich formuleren in termen van (gelabelde) graphen verbindingen tussen knopen met een gewicht kortste pad, grootste flow, bereikbaarheid,.. verschillende representaties als bomen, rij van verbindingen per knoop, globale rij van verbindingen, verbindingsmatrix,.. aantal standaard algoritmen Prim, Kruskal: Minimum Spanning Tree Dijkstra: korste pad Floyd: all pair shortest path Ford-Fulkerson: grootste flow Minimum Spanning Tree Prim: greedy algoritme begin bij een knoop voeg steeds goedkoopste link toe tussen de boom en een nieuwe knoop algoritme geeft ouders van knopen in MST: tree Kruskal greedy algoritme iedere knoop in eigen kluster verbind steeds klusters met de goedkoopste link resultaat is verzameling links (verbindingen)

7 kortste afstand tot startknoop Dijkstra's kortste pad algoritme lijkt erg op Prim in het begin is afstand van wortel tot zichzelf 0 als er geen directe verbinding is, is de afstand greedy algoritme: voeg steeds de knoop toe die het dichts bij de boom ligt alle directe buren van die knoop kunnen hierdoor dichter bij de wortel komen levert afstand tot wortel op i.p.v. ouder 25 kortste afstand tussen alle knopen Floyd-Warshall (all pair shortest path) gebruik completen afstandmatrix in het begin alleen direct verbindingen alle andere afstanden op edge relaxation: maak een steeds betere schatting: W(i,j) k = min ( W(i,j) k-1, W(i,k) k-1 + W(k,j) k-1 ) for ( int k=0; k < g.size; k++ ) for ( int i=0; i < g.size; i++) for ( int j=0; j < g.size; j++ ) { int wk = g.w[i][k] + g.w[k][j]; if ( wk < g.w[i][j] ) g.w[i][j] = wk; } 26 maximale stroom door netwerk netwerk is graph gewicht is capaciteit idee is simpel (Ford-Fulkerson): initieel is de flow 0; while ( er is nog een pad waarover de flow verhoogd kan worden ) verhoog de flow over dat pad; je verhoogt de flow steeds zoveel als mogelijk over het gevonden pad als flow in integers: O ( E f) met f maximale flow variaties in het zoeken van dat pad: depth first breadth first (algoritme het dan Edmonds Karp): verbindingen per knoop A A B E knopen en kanten representatie graph met boomknopen verbindingsmatrix knopen = { A, B, C, D, E } A edges = { (A,A), (A,B) B , (B,D), (B,E) van C , (C,E), (D,E) D E , (E,B), (E,D) O ( V E 2 ) onafhankelijk van f 27 } 28 B D E C E D E E B D A C E B D E C A naar B D A B C D E 7

8 abstractie verberg details maakt het duidelijker kunt niet per ongeluk iets fout doen realisatie: private elementen van klasse module maak programmafragmenten algemener los in een keer meer problemen op goed voor hergebruik realisatie speciale gevallen en stopconditie in extra argumenten klasse hiërarchie templates 29 tentamenstof alles wat we behandeld hebben uit het dictaat 14 tot en met 19, 21, 24 testen, parseren, interpreteren, red-black trees, en graphs staat nog niet in het dictaat de hoofdstukken uit Big C++ die info geven 8, 10, 16-18, 22 lang niet alles staat in het boek 30 Vragen 31 8