die türme von hanoi timm grams fachhochschule fulda fachbereich elektrotechnik und...

Post on 26-Mar-2015

232 Views

Category:

Documents

0 Downloads

Preview:

Click to see full reader

TRANSCRIPT

Die Türme von HanoiDie Türme von Hanoi

Timm GramsTimm Grams

Fachhochschule FuldaFachhochschule Fulda

Fachbereich Elektrotechnik und Fachbereich Elektrotechnik und InformationstechnikInformationstechnik

© Timm Grams, Fulda, 21.11.02© Timm Grams, Fulda, 21.11.02

Die Türme von Hanoi Die Türme von Hanoi - Das - Das ProblemProblem

Gegeben seien drei Pflöcke, die wir mit A, B und C bezeichnen. Zu Beginn stecken auf Pflock A genau n Scheiben. Die Scheiben werden von unten nach oben immer kleiner. Folgende Grundregel ist während des ganzen Spiels einzuhalten: Scheiben werden grundsätzlich auf Pflöcke gesteckt und nie daneben gelegt, und außerdem darf nie eine Scheibe auf einer kleineren liegen. Die Aufgabe lautet, die Scheiben - unter Beachtung der Regel - von Pflock A nach Pflock B zu transportieren.

Die Türme von HanoiDie Türme von Hanoi

A B C

Die Türme von Hanoi Die Türme von Hanoi - - ProgrammideeProgrammidee

Die Aufgabe, n Scheiben vom Quellturm zum Die Aufgabe, n Scheiben vom Quellturm zum Zielturm zu transportieren, führt man auf die wohl Zielturm zu transportieren, führt man auf die wohl etwas einfachere Aufgabe für n-1 Scheiben zurück.etwas einfachere Aufgabe für n-1 Scheiben zurück.

Also: Man bringt die n-1 obersten Scheiben vom Also: Man bringt die n-1 obersten Scheiben vom Ziel- auf den Hilfsturm, dann legt man die unterste Ziel- auf den Hilfsturm, dann legt man die unterste Scheibe auf den Zielturm und anschließend werden Scheibe auf den Zielturm und anschließend werden die n-1 Scheiben vom Hilfsturm auf den Zielturm die n-1 Scheiben vom Hilfsturm auf den Zielturm transportiert. transportiert.

Das Problem für n-1 Scheiben behandelt man nun Das Problem für n-1 Scheiben behandelt man nun genau so. Man führt es zurück auf den Transport genau so. Man führt es zurück auf den Transport von n-2 Scheiben. Und so weiter. Bis man nur noch von n-2 Scheiben. Und so weiter. Bis man nur noch eine Scheibe transportieren muss.eine Scheibe transportieren muss.

Die Türme von Hanoi Die Türme von Hanoi - - ProgrammProgramm

/*A, B, C: Quell-, Ziel und Hilfsturm*//*A, B, C: Quell-, Ziel und Hilfsturm*/

void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1);

printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B);

if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1);

}}

void main(){void main(){

int n;int n;

printf("DIE TUERME VON HANOI\n");printf("DIE TUERME VON HANOI\n");

printf("? Anzahl Scheiben = ");printf("? Anzahl Scheiben = ");

scanf("%d", &n);scanf("%d", &n);

move('A', 'B', 'C', n);move('A', 'B', 'C', n);

}}

Zur Visualisierung des Zur Visualisierung des AblaufsAblaufsAufbau der folgenden FolienAufbau der folgenden Folien

ProgrammspeicherProgrammspeicher

(Ausschnitt)(Ausschnitt)

BefehlszählerBefehlszähler(Program(Program

Counter, PC)Counter, PC)

Stapelspeicher (Stack)Stapelspeicher (Stack)Für jeden Funktionsaufruf wird ein Für jeden Funktionsaufruf wird ein Funktions-segment (Activation Record) Funktions-segment (Activation Record) angelegt.angelegt.

Es wird als ein Blatt Papier visualisiert, Es wird als ein Blatt Papier visualisiert, das auf die bereits daliegenden Papiere das auf die bereits daliegenden Papiere gelegt wird. Es enthält die automatischen gelegt wird. Es enthält die automatischen Variablen für die Parameter und die Variablen für die Parameter und die Rücksprungadresse (RA).Rücksprungadresse (RA).

Nach Beendigung der Funktion wird der Nach Beendigung der Funktion wird der Befehlszähler auf den Wert der Befehlszähler auf den Wert der Rücksprung-adresse (Return Address, RA) Rücksprung-adresse (Return Address, RA) gesetzt und das Segment wird vom Stack gesetzt und das Segment wird vom Stack entfernt. entfernt.

Die TürmeDie Türme

AblauAblauff

Nach Eingabe der Zahl 3 erfolgt Nach Eingabe der Zahl 3 erfolgt im Hauptprogramm der im Hauptprogramm der

Funktionsaufruf Funktionsaufruf "move('A', 'B', 'C', 3);""move('A', 'B', 'C', 3);"..

Das ergibt die folgende Das ergibt die folgende Situation.Situation.

(Das zuunterst liegende Funktionssegment (Das zuunterst liegende Funktionssegment für das Hauptprogramm ist weggelassen für das Hauptprogramm ist weggelassen

worden. Der weitere Fortgang ist dem Wert worden. Der weitere Fortgang ist dem Wert des Befehlszählers zu entnehmen.)des Befehlszählers zu entnehmen.)

BefehlszählerBefehlszähler(Program(Program

Counter, PC)Counter, PC)

Die TürmeDie Türme

ProgrammspeicherProgrammspeicher

(Ausschnitt)(Ausschnitt)

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 1PC: 1

A: 'A'

B: 'C'

C: 'B'

n: 2

RA: 2

A: 'A'

B: 'B'

C: 'C'

n: 1

RA: 2

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 2PC: 2

A: 'A'

B: 'C'

C: 'B'

n: 2

RA: 2

A: 'A'

B: 'B'

C: 'C'

n: 1

RA: 2

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 3PC: 3

A: 'A'

B: 'C'

C: 'B'

n: 2

RA: 2

A: 'A'

B: 'B'

C: 'C'

n: 1

RA: 2

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 4PC: 4

A: 'A'

B: 'C'

C: 'B'

n: 2

RA: 2

A: 'A'

B: 'B'

C: 'C'

n: 1

RA: 2

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 2PC: 2

A: 'A'

B: 'C'

C: 'B'

n: 2

RA: 2

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 3PC: 3

A: 'A'

B: 'C'

C: 'B'

n: 2

RA: 2

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 1PC: 1

A: 'A'

B: 'C'

C: 'B'

n: 2

RA: 2

A: 'B'

B: 'C'

C: 'A'

n: 1

RA: 4

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 2PC: 2

A: 'A'

B: 'C'

C: 'B'

n: 2

RA: 2

A: 'B'

B: 'C'

C: 'A'

n: 1

RA: 4

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 3PC: 3

A: 'A'

B: 'C'

C: 'B'

n: 2

RA: 2

A: 'B'

B: 'C'

C: 'A'

n: 1

RA: 4

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 4PC: 4

A: 'A'

B: 'C'

C: 'B'

n: 2

RA: 2

A: 'B'

B: 'C'

C: 'A'

n: 1

RA: 4

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 4PC: 4

A: 'A'

B: 'C'

C: 'B'

n: 2

RA: 2

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 2PC: 2

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 3PC: 3

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 1PC: 1

A: 'C'

B: 'B'

C: 'A'

n: 2

RA: 4

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 1PC: 1

A: 'C'

B: 'B'

C: 'A'

n: 2

RA: 4

A: 'C'

B: 'A'

C: 'B'

n: 1

RA: 2

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 2PC: 2

A: 'C'

B: 'B'

C: 'A'

n: 2

RA: 4

A: 'C'

B: 'A'

C: 'B'

n: 1

RA: 2

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 3PC: 3

A: 'C'

B: 'B'

C: 'A'

n: 2

RA: 4

A: 'C'

B: 'A'

C: 'B'

n: 1

RA: 2

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 4PC: 4

A: 'C'

B: 'B'

C: 'A'

n: 2

RA: 4

A: 'C'

B: 'A'

C: 'B'

n: 1

RA: 2

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 2PC: 2

A: 'C'

B: 'B'

C: 'A'

n: 2

RA: 4

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 3PC: 3

A: 'C'

B: 'B'

C: 'A'

n: 2

RA: 4

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 1PC: 1

A: 'C'

B: 'B'

C: 'A'

n: 2

RA: 4

A: 'A'

B: 'B'

C: 'C'

n: 1

RA: 4

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 2PC: 2

A: 'C'

B: 'B'

C: 'A'

n: 2

RA: 4

A: 'A'

B: 'B'

C: 'C'

n: 1

RA: 4

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 3PC: 3

A: 'C'

B: 'B'

C: 'A'

n: 2

RA: 4

A: 'A'

B: 'B'

C: 'C'

n: 1

RA: 4

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 4PC: 4

A: 'C'

B: 'B'

C: 'A'

n: 2

RA: 4

A: 'A'

B: 'B'

C: 'C'

n: 1

RA: 4

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 4PC: 4

A: 'C'

B: 'B'

C: 'A'

n: 2

RA: 4

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

A: 'A'

B: 'B'

C: 'C'

n: 3

RA: STOP

PC: 4PC: 4

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

A B

C

PC: STOPPC: STOP

AblauAblauff void move(char A, char B, char C, int n){void move(char A, char B, char C, int n){

1:1: if(n>1) move(A, C, B, n-1);if(n>1) move(A, C, B, n-1); 2:2: printf("%5d:%c ---> %c\n", n, A, B);printf("%5d:%c ---> %c\n", n, A, B); 3:3: if (n>1) move(C, B, A, n-1);if (n>1) move(C, B, A, n-1); 4:4:}}

Das war'sDas war's

So sieht die Sache jetzt ausSo sieht die Sache jetzt aus

A B C

Ende des FoliensatzesEnde des Foliensatzes

top related