Inleiding programmeren in C++ Life Science & Technology 23 februari Universiteit Leiden

Intermezzo #include 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?

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

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?

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

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

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(n 2 ): 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 = 2 k – 1, k vergelijkingen nodig

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

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

Sorteren Simpelsort Bubblesort Insertion sort

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

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!

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

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) = ½n(n-1) vergelijkingen –complexiteit O(n²): kwadratische orde Bubblesort –bij een rij met n elementen (n-1)+(n-2) = ½n(n-1) vergelijkingen –complexiteit O(n²): kwadratische orde Insertion sort –in het slechtste geval (welk geval is dat?) (n-2) + (n-1) = ½n(n-1) –in het beste geval n vergelijkingen –complexiteit O(n²): kwadratische orde

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 } // shellsort Complexiteit: O(n  n) Geen tentamenstof Ook snel: Quicksort