Programmierung in C++

Skript zur Vorlesung Programmierung in C++ IT Kompaktkurs Teil 14: Rekursive Programmierung Wintersemester 2000/2001 Prof. Dr. Manfred Beham Fachhochschule Amberg-Weiden

Empfohlene Literatur: Die C++ Bibel: Die C++ Programmiersprache, Bjarne Stroustrup, Addison-Wesley http://www.addison-wesley.de/ Sonstiges: C-Programmierung lernen, André Willms, Addison-Wesley http://www.addison-wesley.de/katalog/item.asp?bnm=3827314054 C++-Programmierung, André Willms, Addison-Wesley http://www.addison-wesley.de/katalog/item.asp?bnm=3827311527 C++-Programmierung lernen, André Willms, Addison-Wesley http://www.addison-wesley.de/katalog/item.asp?bnm=3827313422 C/C++-Workshop, André Willms, Addison-Wesley http://www.addison-wesley.de/katalog/item.asp?bnm=3827312906 Objektorientiertes Programmieren, Claussen, Springer-Verlag http://www.springer.de/cgi-bin/search_book.pl?isbn=3-540-55748-2 C++ echt einfach, Oliver Böhm, Franzis http://www.franzis.de/_private/suche/std_result.asp Empfohlene Tools (alternativ): Borland C++ Builder 3 Standard http://www.borland.de/bcppbuilder/index.html Borland C++ Compiler 5.5 http://www.borland.com/bcppbuilder/freecompiler/ Microsoft Visual C++ 6.0 http://www.microsoft.com/germany/ Empfohlene WEB-Side http://community.borland.com/cpp/0,1419,2,00.html Anmerkung: Meine Programmbeispiele sind mit Microsoft Visual C++ 6.0 entworfen worden. Sie können meistens unverändert auch auf Borland C++ 5.5 übersetzt werden. Prof. Dr. Manfred Beham, FH Amberg-Weiden Stand: 16.02.01 Seite 2

Inhaltsverzeichnis 14 Rekursive Programmierung... 4 14.1 Die Fakultätsfunktion... 4 14.2 Die Türme von Hanoi... 6 14.3 Ein einfaches Spiel... 8 Prof. Dr. Manfred Beham, FH Amberg-Weiden Stand: 16.02.01 Seite 3

14 Rekursive Programmierung Wir wollen versuchen, zu verstehen, durch welches Prinzip es dem Rechner z.b. möglich wird, eine nur schwer zu übertreffende Spielstrategie zu entwickeln. Dieses Prinzip, das uns die Lösung vieler verwandter Fragestellungen erschließt, ist die rekursive Programmierung. An Hand von drei Beispielen wird gezeigt, wie mit Hilfe rekursiver Prozeduren sehr einfache und elegante Lösungen erstellt werden können: Ein anschauliches einführendes Beispiel findet sich in der Mathematik zur Berechnung der Fakultät. Eine Denksportaufgabe die Türme von Hanoi zeigt ganz deutlich, wie eine Fragestellung auf ein einfacheres Problem zurückgeführt werden kann. Letztlich wollen wir ein einfaches Spiel realisieren, um gegen den Computer anzutreten. 14.1 Die Fakultätsfunktion Die Fakultät einer positiven ganzen Zahl n > 0 wird definiert als Produkt n! = fact( n) = n ( n 1) 2 1 der ganzen Zahlen von 1 bis n. Mit dieser Definition könnten wir sicher eine C++ Funktion realisieren, die dieses Produkt berechnet. Iterative Berechnung der Fakultät: int fact(int n) int prod = 1; while (n > 0) prod *= n--; return prod; Die Fakultät einer Zahl n könnte aber auch wie folgt definiert werden. 1, falls fact( n) = n fact( n 1), n = 0 sonst Das besondere daran ist, daß in der Definition von fact bereits die zu definierende Funktion verwendet wird. Eine solche Definition heißt rekursiv. Die Berechnung der Fakultät der Zahl n wird auf die Berechnung der Fakultät von n-1 zurückgeführt. Neu für uns ist, daß auch C++ die rekursive Definition von Funktionen zuläßt. Das bedeutet, daß man in dem Definitionsblock einer Funktion diese Funktion bereits aufrufen kann. Damit lassen sich derartige rekursive Definitionen eins zu eins in C++ Programmcode umsetzen. Und wir können die Fakultät nun auch ohne die Verwendung einer while-schleife programmieren. Die Funktion fact besteht aus einer bedingten Anweisung, die im Falle von n größer als 0, wieder die Funktion fact, nun mit n-1, aufruft. Prof. Dr. Manfred Beham, FH Amberg-Weiden Stand: 16.02.01 Seite 4

Rekursive Berechnung der Fakultät: int fact(int n) if (n > 0) return n * fact(n-1); else return 1; Betrachten wir zum Verständnis dieser rekursiven Prozedur die Berechnung der Fakultät von 4. Unsere Funktion fact wird also mit dem Wert n = 4 aufgerufen. Die Berechnung des Funktionswertes, führt im if-zweig der bedingten Anweisung auf den Ausdruck: 4 * fact(3) Bevor dieser Ausdruck berechnet werden kann, muß das Ergebnis von fact(3) berechnet werden. Dies führt zu einem erneuten Aufruf der Funktion, diesmal mit dem Argument 3. Das Ergebnis dieses Aufrufs muß dann noch mit 4 multipliziert werden. Ebenso führt der Aufruf von fact(3) zu einem erneuten Aufruf der Funktion fact, diesmal mit dem Argument 2. Dieser Ablauf wird fortgesetzt, bis man beim Aufruf von fact(0) angelangt ist und das Ergebnis von 1 sofort ohne weitere Berechnungen im else-zweig erhält, da nun n nicht mehr größer als 0 ist. Das Ergebnis von fact(0) wird nun an den Aufrufenden fact(1) weitergereicht. Um das Ergebnis für fact(1) zu berechnen, muß noch mit 1 multipliziert werden; und so ergibt fact(1) = 1 * 1 = 1. So geht es rückwärts, bis fact(4) schließlich zu 4 * 6 = 24 berechnet wird. Folgende Abbildung stellt diese Aufrufkette dar. Aufrufe Rückgabe fact(4) = 4*fact(3) = 4 * 6 = 24 fact(3) = 3*fact(2) = 3 * 2 = 6 fact(2) = 2*fact(1) = 2 * 1 = 2 fact(1) = 1*fact(0)= 1*1 = 1 fact(0) = 1 Abbildung 1:Rekursive Aufrufe der Funktion fact zur Berechnung der Fakultät von 4. Prof. Dr. Manfred Beham, FH Amberg-Weiden Stand: 16.02.01 Seite 5

Die richtige Durchführung dieser Berechnung organisiert der Compiler mit Hilfe unserer rekursiven Definition vollkommen automatisch. Damit die Rekursion richtig funktioniert, muß sich der Programmierer nur um zwei Dinge kümmern: Grundprinzip rekursiver Prozeduren: Die entstehenden rekursiven Aufrufe müssen immer einfacher werden. Und schließlich auf einen nicht rekursiven Fall führen, der die Aufrufkette abbricht. Rekursive Algorithmen können daher immer auf Probleme angewandt werden, die sich auf ein gleichartiges, aber einfacheres Problem zurückführen lassen. Und es muß eine Lösung für ein elementares Problem existieren. Das gilt auch für unser folgendes Beispiel. 14.2 Die Türme von Hanoi Bei dieser Knobelaufgabe müssen N Scheiben von einer Ausgangsposition zu einer Zielposition bewegt werden. Dazu dürfen die Scheiben auf einer Zwischenposition abgelegt werden. Der Durchmesser der Scheiben nimmt von unten nach oben hin kontinuierlich ab. Beim Transport der Scheiben müssen folgende 2 Regeln eingehalten werden: 1. Es darf nie eine größere Scheibe auf einer kleineren abgelegt werden. 2. Es darf in einem Zug immer nur eine Scheibe bewegt werden. A B C Ausgangsposition Zwischenposition Zielposition Abbildung 2: Die Türme von Hanoi - Ausgangssituation. Beim ersten Probieren werden wir bereits feststellen, daß kleinere Türme wiederholt umgesetzt werden müssen. Das Problem 5 Scheiben umzusetzen läßt sich also auf kleinere Probleme mit weniger Scheiben zurückführen und damit haben wir bereits das Prinzip für eine systematische Lösung mit Hilfe der Rekursion erkannt. Wir wollen uns jetzt vorstellen, wir hätten bereits eine Lösung gefunden, wenn die Höhe des Turmes nur um 1 kleiner wäre. Wir kennen also eine Lösung, um einen Turm von 4 Scheiben von einem Ort zu einem anderen Platz zu bewegen und wir könnten sicher auch die Rollen der Plätze als Zwischenlager bzw. Zielposition vertauschen. Damit gestaltet sich das Problem der 5 Scheiben sehr einfach: Prof. Dr. Manfred Beham, FH Amberg-Weiden Stand: 16.02.01 Seite 6

Transportiere die oberen 4 Scheiben zur Zwischenablage. Die unterste, größte Scheibe würde dabei sicher nicht stören. Die übriggebliebene größte Scheibe können wir jetzt ungehindert auf ihre Zielposition bewegen. Schließlich müssen wir noch den 4er Turm von der Zwischenablage auf die Zielposition transportieren; aber dafür kennen wir ja bereits wie angenommen eine Lösung, die sich nicht wesentlich von unserem ersten Transport des 4er Turms unterscheiden wird. Lediglich Ausgangsposition und Zielposition haben gewechselt. Ich behaupte nun, damit ist die Knobelaufgabe erschöpfend gelöst. Wir haben also die Aufgabe, einen Turm der Höhe N zu bewegen, auf eine einfachere aber gleichartige Aufgabe zurückgeführt. Und es gibt auch eine elementare Lösung für Türme, die aus nur einer Scheibe bestehen. Prinzip der Rekursion Die rekursiv formulierte Lösung des Problems können wir sehr einfach in C++ umsetzen. Wir benötigen eine Funktion die folgende Parameter hat: Die Höhe, d.h. die Anzahl N an Scheiben, des umzusetzenden Turms. Drei Parameter, die die Belegung der drei Plätze beschreiben: - Ausgangsposition - Zwischenablage - Zielposition Rekursive Prozedur Hanoi: // Die Türme von Hanoi void Hanoi (int Hoehe, char Ausgang, char Zwischen, char Ziel) if (n > 0) Hanoi(Hoehe-1, Ausgang, Ziel, Zwischen); ziehe(n, Ausgang, Ziel); Hanoi(Hoehe-1, Zwischen, Ausgang, Ziel); void ziehe (int i, char Von, char Nach) cout << "ziehe Scheibe " << i << ", " << Von << " -> " << Nach << endl; Diese wenigen Programmzeilen bewegen nun jede Turmhöhe an die richtige Position. Dazu müssen wir die Funktion Hanoi nur mit der Turmhöhe, der Ausgangsposition und dem gewünschten Zielplatz / Zwischenplatz aufrufen. Hier soll ein Turm von 5 Scheiben von A nach C bewegt werden, wobei B als Zwischenlager genutzt wird. Aufruf der Prozedur Hanoi: // Lösung für die Türme von Hanoi der Höhe 5 int main () Hanoi (5, 'A', 'B', 'C'); return 0; Prof. Dr. Manfred Beham, FH Amberg-Weiden Stand: 16.02.01 Seite 7

Wenn sie nun den Anweisungen des Computers folgen, haben sie obendrein eine Lösung, die mit einer minimalen Anzahl an Scheibenbewegungen das gewünschte Ziel erreicht. 14.3 Ein einfaches Spiel Anhand eines einfachen Spiels für zwei Spieler, das dem NIM-Spiel verwandt ist, wollen wir zeigen, wie der Computer Spielstellungen bewerten kann, um einen möglichst optimalen Spielzug zu finden. Das Spiel: Zwei Spieler müssen abwechselnd Münzen aus einer Menge von Münzen nehmen. In jedem Zug darf ein Spieler entweder 3, 5, oder 7 Münzen entfernen. Kann ein Spieler nicht mehr ziehen, so hat er verloren. Wir starten mit einer zufälligen Zahl an Münzen. Dieses Spiel zu gewinnen, ist nicht schwer, da es eine einfache Gewinn-Strategie gibt. Wenn der Spieler die Strategie kennt und konsequent verfolgt, hat der Gegner von vornherein keine Chance. Für gewisse Anfangswerte von Münzen hat der Spieler, der beginnt, eine sichere Gewinnstrategie, für andere Anfangswerte gewinnt der zweite Spieler. Wenn beide die Strategie kennen, kann man nur noch hoffen, dass einer einen Fehler macht und das ist natürlich langweilig. Um nun unseren Computer in die Lage zu versetzen, dieses Spiel optimal zu spielen, wollen wir eine Funktion (Prädikat) zur Bewertung einer gegebenen Spielsituation entwickeln, welche uns sagen soll, ob der Spieler, der am Zug ist, eine sichere Gewinnmöglichkeit hat. Das Argument dieser Funktion ist die gegebene Spielsituation, die bewertet werden soll. Die Beschreibung einer gegebenen Spielsituation ist einfach die Anzahl der vorliegenden Münzen. Also eine ganze Zahl beschreibt den aktuellen Stand des Spiels ausreichend. Wir nennen unsere boolsche Funktion 'goodposition' und sie soll wahr liefern, wenn eine günstige Situation vorliegt und falsch wenn wir in einer Verlustsituation sind. Das Prädikat goodposition: // Spielstellung mit Gewinnmöglichkeit bool goodpos (int n) if (n < 3) return false; // schon verloren else if (n <= 9) return true; // klar wie ich gewinne else // ich gewinne, falls die Folgesituation schlecht ist return!goodpos(n-7)!goodpos(n-5)!goodpos(n-3); Für einige wenige Münzen ist ganz klar wer gewinnen oder verlieren wird. Bei weniger als 3 Münzen haben wir in jedem Fall verloren, da kein weiterer Zug mehr möglich ist. goodpos ergibt false. Zwischen 3 und 9 Münzen können wir durch Wegnahme von 3, 5 oder 7 Münzen die Anzahl immer soweit reduzieren, das der Gegner nicht mehr ziehen kann. Das ist also für den Spieler der am Zug ist eine höchst erfreuliche Situation, die in jedem Fall zum Gewinn führt also goodpos liefert true. Alle anderen Spielsituation können wir dann als für uns günstig bewerten, wenn wir durch irgend einen erlaubten Spielzug den Gegner in eine schlechte Situation zwingen können. Genau das versucht die Prof. Dr. Manfred Beham, FH Amberg-Weiden Stand: 16.02.01 Seite 8

Oder-Verknüpfung der möglichen Folge-Situationen, zu denen der Spieler, der am Zug ist, ziehen darf. Wenn irgend eine der Folgesituationen als "schlechte Position" (goodpos = false) zu bewerten ist, werden wir gewinnen also unsere Position ist gut. Die Funktion goodpos ist ein weiteres Beispiel für eine rekursive Prozedur, da für mehr als 9 Münzen die Funktion sich selbst aufruft. Das besondere hierbei ist, das die Funktion alle möglichen Spielzüge ausprobieren muß, falls die Aufrufe nicht eine "schlechte" Position finden. Zur Bewertung einer beliebigen Spielsituation muß das Spiel also durch die rekursiven Aufrufe bis zum Spielende verfolgt werden, um zu entscheiden, ob ein Spielzug zum Erfolg führt. Zur Bewertung einer Spielsituation werden durch diese Oder- Verknüpfung nacheinander alle in Frage kommenden Spielzüge getestet. Bei Mißerfolg wird der Versuch zurückgezogen und die nächste Möglichkeit getestet. Dieses Verfahren setzt sich in den rekursiven Aufrufen von goodposition fort. Derartige rekursive Suchverfahren nennt man Backtracking-Verfahren Falls es keine weiteren alternativen Zugmöglichkeiten gibt, ist die aktuelle Spielsituation als "schlecht" zu bewerten. Die Auswertung der Oder-Verknüpfung kann allerdings abgebrochen werden, wenn ein passender Zug gefunden wurde; d.h.!goodpos() = true. Die anderen Alternativen müssen dann nicht mehr getestet werden. Der Operator wertet die Operanden von links nach rechts aus, solange nicht einer bereits true liefert. Beim Schachspiel explodiert der nötige Suchaufwand allerdings relativ schnell, da es in jeder Spielsituation eine große Menge möglicher Zug-Alternativen gibt. Deshalb können Schachprogramme die Suche nach einem optimalen Spielzug, nur bis zu einer gewissen Tiefe und nicht bis zum Ende des Spieles verfolgen. Daher kann ein Schachprogramm für eine beliebige Spielstellung auch nicht entscheiden ob es sich um eine Gewinn- oder Verlustsituation handelt. Statt dessen versucht man im Schach die Spielstellungen zu bewerten. Das bedeutet, das die Funktion zur Beurteilung der Spielsituation nicht mehr nur wahr oder falsch ausspuckt, sondern eine Zahl, die angibt wie gut oder schlecht eine bestimmte Spielstellung ist. Die Aufgabe der Suche nach einem optimalen Zug besteht nun darin, von allen Alternativen, diejenige zu wählen, die die beste Bewertung bekommt. Ein vollständiges Spielprogramm Unsere Funktion goodpos bildet den Kern eines Programms, das auch selber spielen kann. Wenn der Computer am Zug ist, wählt er aus allen möglichen Zügen einfach denjenigen aus, der in eine Spielsituation führt, für die goodpos falsch ist. Wenn eine solche Situation existiert, erhält der Gegner, der ja nun am Zug ist, eine "schlechte" Situation und ihm bleibt keine Chance. Existiert eine solche Stellung nicht, dann muß der Computer irgendeinen Spielzug zufällig wählen und ausführen. Er hat nur dann noch eine Chance, wenn der Gegner einen Fehler macht. In den Programmbeispielen finden sie ein vollständiges Spielprogramm. Prof. Dr. Manfred Beham, FH Amberg-Weiden Stand: 16.02.01 Seite 9