Informatik 1 D-ITET Herbstsemester 2009 Übungstunde 8. Gruppe 7 ETZ F91 / 17-19h. Stefan Lienhard

Transkript

1 Informatik 1 D-ITET Herbstsemester 2009 Übungstunde 8 Gruppe 7 ETZ F91 / 17-19h Stefan Lienhard stefalie@ee.ethz.ch

2 Übersicht (Nachbesprechung Übung 6) (Nachbesprechung Übung 7) Theorie: Rekursion Vorbesprechung Übung 8 Labyrinth 2 / 24

3 Ü6, A1.1 Stack mit dyn. Array // Pointer auf das Array int* data; // Anzahl Elemente im Stack int numberofelements; // Gegenwärtige Kapazität des Arrays int sizeofarray; void init() { numberofelements = 0; sizeofarray = 2; data = new int[sizeofarray]; void clear() { delete[] data; numberofelements = 0; 3 / 24

4 Ü6, A1.1 Stack mit dyn. Array int pop() { // Prüfen ob der Stack leer ist -> Fehler if (numberofelements < 1) { cout << "Stack underrun: Stack is empty!" << endl; return -1; else { numberofelements--; return data[numberofelements]; return 0; void push(int element) { // Falls Kapazität erschöpft: Neues Array erstellen if (sizeofarray <= numberofelements) { int* tempdata = new int[2 * sizeofarray]; for (int i = 0; i < sizeofarray; i++) tempdata[i] = data[i]; sizeofarray = 2* sizeofarray; delete[] data; data = tempdata; data[numberofelements] = element; numberofelements++; 4 / 24

5 Ü6, A1.2 Stack mit Liste struct item { int key; item* next; ; // Wert des Stackelements // Pointer zum unteren Element item* first; // Pointer auf oberstes Stapelelement int numberofelements; void init() { first = NULL; numberofelements = 0; void clear() { while (numberofelements > 0) pop(); // Den Stack leer poppen. 5 / 24

6 Ü6, A1.2 Stack mit Liste int pop(){ int result; if (first!= NULL) { item* temp = first; result = first->key; first = first -> next; delete temp; // nicht vergessen: Altes Element löschen numberofelements--; else { //Stack ist leer -> Fehler cout << "Stack underrun: Stack is empty!" << endl; result = -1; return result; void push(int element){ item* ni = new item; ni->key = element; ni->next = first; first = ni; numberofelements++; 6 / 24

7 Bemerkungen zur Ü6 delete vs. delete[] int *p = new int; delete p; int *p = new int[10]; delete[] p; Vergrössern des Array bei push() Array nicht doppelt kopieren pop() Fehlermeldung ausgeben falls der Stack leer ist sonst sonst überschreitet man die Arraygrenzen oder dereferenziert NULL. 7 / 24

8 Ü7 - Filter Funktion zur Bestimmung der Filterlänge ist im Template gegeben Funktion zum Einlesen des Filters: void read_filter(const char *file, double buffer[]) { ifstream fin(file); if(!fin.is_open()) { cerr << "Error: failed to open " << file; exit(1); int len = 0; while (fin >> buffer[len++]) ; 8 / 24

9 Ü7 Filter int main(int argc, char **argv) { istream in(argv[2]); ostream out(argv[3]); int lf = get_filter_size(argv[1]); double *buffer = new double[lf]; double *filter = new double[lf]; // save index of last changed element in ring buffer int n = 0; // skip comments while (in.peek() == '#') { string s; getline(in, s); // read filter read_filter(argv[1], filter); // fill buffer with zeros for (int i=0; i<lf; ++i) buffer[i] = 0;... 9 / 24

10 Ü7 Filter while(in >> d) { buffer[n % lf] = d; // save element in ring buffer // skip elements as long as we don't have enough to convolve if(n >= lf / 2) { out << convolute(filter, buffer, lf, n) << endl; n++; // handle end overlap int stop = lf / 2; for(int i = 0; i < stop; ++i) { buffer[(n + i) % lf] = 0; // write 0 instead of reading out << convolute(filter, buffer, lf, n + i) << endl; delete [] buffer; delete [] filter; return 0; 10 / 24

11 Ü7 - Filter Faltungsfunktion: double convolute(double filter[], double buffer[], int lf, int n) { double sum = 0; for(int k = 0; k < lf; ++k) { sum += filter[k] * buffer[(lf + n k) % lf]; return sum; 11 / 24

12 Rekursion: Fakultät Rekursion: Eine Funktion ruft sich selber auf Beispiel Fakultät: n! = n * (n-1)! f(n) = n * f(n-1) f(0) = f(1) = 1 int fak(int n) { if (n <= 1) return 1; Eine Rekursion braucht genau wie eine Schleife auch eine Abbruchbedingung else return n * fak(n-1); Rekursiver Funktionsaufruf 12 / 24

13 Rekursion: Fibonacci Fibonacci Folge: 1, 1, 2, 3, 5, 8, 13, 21, 34, fib(n) = fib(n-1) + fib(n-2) fib(1) = fib(2) = 1 int fib(int n) { if (n == 1 n == 2) return 1; else return fib(n-1) + fib(n-2); 13 / 24

14 Rekursion: Türme von Hanoi Bewege alle Scheiben vom linken Stapel zum rechten Stapel. Dabei darf jeweils nur die oberste Scheibe verschoben werden. Zu jedem Zeitpunkt dürfen sich unter jeder Scheibe nur grössere befinden. 14 / 24

15 Rekursion: Türme von Hanoi void move(int n, char a, char b, char c) { if(n == 0) Verschiebe n Scheiben von a nach c return; und benutze b als Zwischenstapel. move(n-1, a, c, b); cout << "Verschiebe die Scheibe " << n; cout << " von " << a << " nach "; cout << c << endl; move(n-1, b, a, c); int main() { move(3,'a','b','c'); return 0; 15 / 24

16 Rekursion: Türme von Hanoi move(3,'a','b','c'); - move(2,'a','c','b'); - move(1,'a','b','c'); - move(0,'a','c','b'); `- move(0,'b','a','c'); `- move(1,'c','a','b'); - move(0,'c','b','a'); `- move(0,'a','c','b'); `- move(2,'b','a','c'); - move(1,'b','c','a'); - move(0,'b','a','c'); `- move(0,'c','b','a'); `- move(1,'a','b','c'); - move(0,'a','c','b'); `- move(0,'b','a','c'); Verschiebe die Scheibe 1 von a nach c Verschiebe die Scheibe 2 von a nach b Verschiebe die Scheibe 1 von c nach b Verschiebe die Scheibe 3 von a nach c Verschiebe die Scheibe 1 von b nach a Verschiebe die Scheibe 2 von b nach c Verschiebe die Scheibe 1 von a nach c 16 / 24

17 Vorbesprechung Übung 8 Datei labyrinth.h stellt schon vieles zur Verfügung #ifndef LABYRINTH_H #define LABYRINTH_H int sizex(); int sizey(); int loadlabyrinth(char *filename); void resetlabyrinth(); void printlabyrinth(); char zeichenanposition(int x, int y); void setzezeichen(char zeichen, int x, int y); #endif 17 / 24

18 Labyrinth Das Programm soll in eine neue.cpp Datei geschrieben werden (z.b. pathfinder.cpp). Die Dateien aus dem Framework sollten im selben Verzeichnis abgelegt sein: labyrinth.cpp labyrinth.h labyrinth.map pathfinder.cpp Kompilierung: g++ -g -Wall -o pathfinder labyrinth.cpp pathfinder.cpp 18 / 24

19 Labyrinth Startpunkt (pathfinder.cpp): #include <iostream> #include "labyrinth.h" using namespace std; bool sucheweg(int sx, int sy, int zx, int zy); int main() { if (loadlabyrinth("labyrinth.map")!= 0) cout << "Konnte Labyrinth nich laden." << endl; printlabyrinth(); //... up to you to complete this return 0; bool sucheweg(int sx, int sy, int zx, int zy) { / 24

20 Labyrinth XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 1 X X X X X X 2 X X X X X X 3 X X XXXXXXX X X 4 X XXXXX X X 5 X X X XXXX X 6 X X X X X 7 X XXX X XX X X 8 X X XXXX XX X X 9 X XXX X X X X 10 X X X XXXXXX 11 X X X XXXXXX XXX X 12 X XXXXXX X XXX X 13 X X X 14 X XXXXX X 15 X XXXXXXXXXXXXXXXX X X 16 X X X X XXXXXX 17 X X X X X 18 X X X 19 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 20 / 24

21 Labyrinth - Roadmap Das Labyrinth laden (loadlabyrinth()) Labyrinth auf dem Bildschirm ausgeben Start und Ziel-Koordinaten vom Benutzer einlesen Eingaben prüfen Weg im Labyrinth suchen und diesen Weg auf dem Bildschirm anzeigen Rekursive Funktion sucheweg 21 / 24

22 Labyrinth - Roadmap Rekursive Funktion: bool sucheweg(int sx, int sy, int zx, int zy) Abbruch wenn Start und Ziel-Koordinaten übereinstimmen (return true) Abbruch wenn aktuelle Start-Koordinate kein leeres Feld ist (return false) Versuche zuerst einen Schritt nach rechts Zeichen > an aktuelle Start-Koordinate schreiben Rekursiver Aufruf mit Start-Koordinate 1 Feld rechts der aktuellen Start-Position Falls dieser Aufruf true zurück gibt: Ebenfalls true zurück geben Sonst: Die restlichen drei Richtungen versuchen Wichtig: Wenn alle vier Richtungen erfolglos waren wird das Startfeld mit einem Zeichen (z.b. Punkt) versehen. Danach wird false zurück gegeben. 22 / 24

23 Fragen? 23 / 24

24 Slides 24 / 24