Inleiding programmeren in C Life Science Technology 23

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

Intermezzo #include <iostream> using namespace std; // ZIE DIKTAAT void alias (int r, int t; t = 3; r = r + 2; s = s + t = t + 1; r = r cout << r << s << t } // alias int main ( ) { int t = 12; } // main & s ) { r + t; 3; << endl; alias (t, t); cout << endl; return 0; 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 verhaalnvan twee regels"; string zoekwoord; int woordlengte, verhaallengte = mijnverhaal. length ( ); int startwoord, i; cout << "Zoek woord: "; cin >> zoekwoord; // leest een heel 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 i, // j, // temp; // } (int A[ ], int n) { i-de element straks steeds invoegen om reeds gesorteerde stuk af te lopen 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)+. . . +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

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