Inleiding programmeren in C++ Life Science & Technology 23 februari 2004

1. Inleiding programmeren in C++Life Science & Technology23 februari 2004 http://www.liacs.nl/home/kosters/lst Universiteit Leiden

2. Intermezzo #include <iostream> using namespace std; // ZIE DIKTAAT void alias (int r, int & s ) { int t; t = 3; r = r + 2; s = s + r + t; t = t + 1; r = r - 3; cout << r << s << t << endl; } // alias int main ( ) { int t = 12; alias (t,t); cout << t << endl; return 0; } // main Wat gebeurt er? En wat als er een & bij int r wordt tussengevoegd?

3. Week 6 • Inhoud • Zoeken en sorteren • Doel • De meest gebruikte array-operaties snappen • Materiaal • Dictaat Hoofdstuk 3.8 en opgaven 42/46 • De tweede programmeeropgave • Werkcollege • Werken aan de tweede programmeeropgave, met name de optie Sorteren

4. Zoeken en sorteren • Lineair zoeken • Van links naar rechts in een niet-gesorteerde rij zoeken • Binair zoeken • Handig zoeken in een gesorteerde rij • Simpelsort • Kleinste (lineair) zoeken en omwisselen met de voorste • Bubblesort • Elementen die verkeerd-om staan omwisselen tot alles goed staat • Insertion sort • Voeg ieder element op de juiste plaats tussen (in een nieuwe of de bestaande rij), net als bij kaarten • Hoe zit het met de complexiteit van deze algoritmen?

5. Lineair zoeken int lineairzoeken (int rij[ ], int lengte, int getal) { int index = 0; bool gevonden = false; while ( ! gevonden && index < lengte ) if ( getal == rij[index] ) gevonden = true; // of: return index; else index++; if ( gevonden ) return index; else return -1; } // lineairzoeken

6. Binair zoeken int binairzoeken (int rij[ ], int rechts, int getal) { int links = 0, midden; bool gevonden = false; while ( ! gevonden && links <= rechts ) { midden = (links + rechts) / 2; if (getal == rij[midden]) gevonden = true; // of: return midden; else if ( getal > rij[midden] ) links = midden + 1; else rechts = midden - 1; } // while if ( gevonden ) return midden; else return -1; } // binairzoeken

7. Complexiteit zoekalgoritmen • Verband tussen de grootte van het probleem en de hoeveelheid “werk” (bijvoorbeeld het aantal vergelijkingen) om het probleem op te lossen • Uitgedrukt in een “orde”, • bijvoorbeeld O(n2): kwadratische orde • Lineair zoeken • in een ongesorteerde rij • complexiteit O(n): lineaire orde • Binair zoeken • alleen in een gesorteerde rij • complexiteit O(log n): logaritmische orde, want in het slechtste geval zijn voor een rij van lengte n = 2k – 1, k vergelijkingen nodig

8. Zoeken in tekst (1) // Zoek een woord van lengte woordlengte (woord.length ( ) zou ook kunnen) // in een verhaal van lengte verhaallengte (idem verhaal.length ( )) // Resultaat is de startplek van het woord // en -1 als het woord niet is gevonden int komtvoor (string woord, string verhaal, int woordlengte, int verhaallengte) { int i = 0, j; bool gevonden = false; while ( ! gevonden && ( i + woordlengte <= verhaallengte ) ) { gevonden = true; for ( j = 0; j < woordlengte; j++ ) if ( woord[j] != verhaal[i+j] ) gevonden = false; i++; } // while if ( gevonden ) return (i-1); else return -1; } // komtvoor

9. Zoeken in een tekst (2) int main ( ) { string mijnverhaal = "Dit is een lang verhaal\nvan twee regels"; string zoekwoord; int woordlengte, verhaallengte = mijnverhaal.length ( ); int startwoord, i; cout << "Zoek woord: "; cin >> zoekwoord; // leest een heel woord woordlengte = zoekwoord.length ( ); startwoord = komtvoor (zoekwoord, mijnverhaal, woordlengte, verhaallengte); if ( startwoord >= 0 ) { cout << "Gevonden op plek " << startwoord << " het woord "; for ( i = startwoord; i < startwoord + woordlengte; i++ ) cout << mijnverhaal[i]; cout << endl; } // if else cout << "Woord niet gevonden." << endl; return 0; } // main

10. Sorteren • Simpelsort • Bubblesort • Insertion sort

11. Simpelsort void simpelsort (int rij[ ], int lengte) { int voorste, kleinste, plaatskleinste, k; for ( voorste = 0; voorste < lengte; voorste++ ) { plaatskleinste = voorste; kleinste = rij[voorste]; for ( k = voorste + 1; k < lengte; k++ ) { if ( rij[k] < kleinste ) { kleinste = rij[k]; plaatskleinste = k; } // if } // for-k if ( plaatskleinste > voorste ) wissel (rij[plaatskleinste], rij[voorste]); } // for-voorste } // simpelsort

12. Bubblesort void bubblesort (int rij[ ], int lengte) { int ronde, j; for ( ronde = 1; ronde < lengte; ronde++ ) for ( j = 0; j < lengte - ronde; j++ ) if ( rij[j] > rij[j+1] ) wissel (rij[j], rij[j+1]); } // bubblesort int main ( ) { int getallen[MAX]; ... bubblesort (getallen, MAX); ... } // main Mogelijke verbetering: stoppen als er een hele ronde niet gewisseld is Let op de dubbele loop!

13. Insertion sort void invoegsorteer (int A[ ], int n) { int i, // i-de element straks steeds invoegen j, // om reeds gesorteerde stuk af te lopen temp; // om tijdelijk tussen te voegen getal te bevatten for ( i = 1; i < n; i++ ) { // voeg A[i] in op juiste plaats temp = A[i]; j = i - 1; while ( ( j >= 0 ) && ( A[j] > temp ) ) { A[j+1] = A[j]; j--; } // while A[j+1] = temp; } // for } // invoegsorteer Variant: maak een nieuwe (lege) rij en voeg elk element op de juiste plaats tussen

14. Complexiteit sorteeralgoritmen • Simpelsort • de kleinste zoeken in een rij van n-1 elementen, dan in een rij van n-2 elementen, enzovoorts: (n-1)+(n-2)+...+3+2+1 = ½n(n-1) vergelijkingen • complexiteit O(n²): kwadratische orde • Bubblesort • bij een rij met n elementen (n-1)+(n-2)+...+3+2+1 = ½n(n-1) vergelijkingen • complexiteit O(n²): kwadratische orde • Insertion sort • in het slechtste geval (welk geval is dat?) 1 + 2 + ... + (n-2) + (n-1) = ½n(n-1) • in het beste geval n vergelijkingen • complexiteit O(n²): kwadratische orde

15. Shellsort void shellsort (int rij[ ], int lengte) { int i, j, sprong = lengte; bool klaar; while ( sprong > 1 ) { sprong = sprong / 2; klaar = false; while ( ! klaar ) { // soort bubblesort klaar = true; for ( i = 0; i <= lengte-sprong-1; i++ ) { j = i + sprong; if ( rij[i] > rij[j] ) { wissel (rij[i], rij[j]); klaar = false; } // if } // for } // while } // while } // shellsort Complexiteit: O(nn) Geen tentamenstof Ook snel: Quicksort