1. Fachbereich Elektrotechnik und Informationstechnik
Die Türme von Hanoi
Timm Grams
Fachhochschule Fulda
Fachbereich Elektrotechnik und Informationstechnik
© Timm Grams, Fulda,

2. Die Türme von Hanoi - Das Problem
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.

3. Die Türme von Hanoi A B C

4. Die Türme von Hanoi - Programmidee
Die Aufgabe, n Scheiben vom Quellturm zum Zielturm zu transportieren, führt man auf die wohl etwas einfachere Aufgabe für n-1 Scheiben zurück.
Also: Man bringt die n-1 obersten Scheiben vom Ziel- auf den Hilfsturm, dann legt man die unterste Scheibe auf den Zielturm und anschließend werden die n-1 Scheiben vom Hilfsturm auf den Zielturm transportiert.
Das Problem für n-1 Scheiben behandelt man nun genau so. Man führt es zurück auf den Transport von n-2 Scheiben. Und so weiter. Bis man nur noch eine Scheibe transportieren muss.

5. Die Türme von Hanoi - Programm
/*A, B, C: Quell-, Ziel und Hilfsturm*/
void move(char A, char B, char C, int n){
if(n>1) move(A, C, B, n-1);
printf("%5d:%c ---> %c\n", n, A, B);
if (n>1) move(C, B, A, n-1); }
void main(){
int n;
printf("DIE TUERME VON HANOI\n");
printf("? Anzahl Scheiben = ");
scanf("%d", &n);
move('A', 'B', 'C', n);

6. Zur Visualisierung des Ablaufs Aufbau der folgenden Folien
Programmspeicher
(Ausschnitt)
Befehlszähler
(Program
Counter, PC)
Stapelspeicher (Stack)
Für jeden Funktionsaufruf wird ein Funktions-segment (Activation Record) angelegt.
Es wird als ein Blatt Papier visualisiert, das auf die bereits daliegenden Papiere gelegt wird. Es enthält die automatischen Variablen für die Parameter und die Rücksprungadresse (RA).
Nach Beendigung der Funktion wird der Befehlszähler auf den Wert der Rücksprung-adresse (Return Address, RA) gesetzt und das Segment wird vom Stack entfernt.
Die Türme

7. Das ergibt die folgende Situation.
Ablauf
Programmspeicher
(Ausschnitt)
Befehlszähler
(Program
Counter, PC)
Nach Eingabe der Zahl 3 erfolgt im Hauptprogramm der Funktionsaufruf "move('A', 'B', 'C', 3);".
Das ergibt die folgende Situation.
(Das zuunterst liegende Funktionssegment für das Hauptprogramm ist weggelassen worden. Der weitere Fortgang ist dem Wert des Befehlszählers zu entnehmen.)
Die Türme

8. Ablauf PC: 1 C A: 'A' B: 'B' A: 'A' A: 'A' B: 'C' C: 'C' B: 'B' C: 'B'
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 1 C
A: 'A'
B: 'B'
C: 'C'
n: 1
RA: 2
A: 'A'
B: 'C'
C: 'B'
n: 2
RA: 2
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

9. Ablauf PC: 2 C A: 'A' B: 'B' A: 'A' A: 'A' B: 'C' C: 'C' B: 'B' C: 'B'
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 2 C
A: 'A'
B: 'B'
C: 'C'
n: 1
RA: 2
A: 'A'
B: 'C'
C: 'B'
n: 2
RA: 2
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

10. Ablauf PC: 3 C A: 'A' B: 'B' A: 'A' A: 'A' B: 'C' C: 'C' B: 'B' C: 'B'
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 3 C
A: 'A'
B: 'B'
C: 'C'
n: 1
RA: 2
A: 'A'
B: 'C'
C: 'B'
n: 2
RA: 2
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

11. Ablauf PC: 4 C A: 'A' B: 'B' A: 'A' A: 'A' B: 'C' C: 'C' B: 'B' C: 'B'
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 4 C
A: 'A'
B: 'B'
C: 'C'
n: 1
RA: 2
A: 'A'
B: 'C'
C: 'B'
n: 2
RA: 2
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

12. Ablauf PC: 2 C A: 'A' A: 'A' B: 'C' B: 'B' C: 'B' C: 'C' n: 2 n: 3
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 2 C
A: 'A'
B: 'C'
C: 'B'
n: 2
RA: 2
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

13. Ablauf PC: 3 C A: 'A' A: 'A' B: 'C' B: 'B' C: 'B' C: 'C' n: 2 n: 3
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 3 C
A: 'A'
B: 'C'
C: 'B'
n: 2
RA: 2
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

14. Ablauf PC: 1 C A: 'B' A: 'A' B: 'C' A: 'A' B: 'C' C: 'A' B: 'B' C: 'B'
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 1 C
A: 'B'
B: 'C'
C: 'A'
n: 1
RA: 4
A: 'A'
B: 'C'
C: 'B'
n: 2
RA: 2
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

15. Ablauf PC: 2 C A: 'B' A: 'A' B: 'C' A: 'A' B: 'C' C: 'A' B: 'B' C: 'B'
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 2 C
A: 'B'
B: 'C'
C: 'A'
n: 1
RA: 4
A: 'A'
B: 'C'
C: 'B'
n: 2
RA: 2
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

16. Ablauf PC: 3 C A: 'B' A: 'A' B: 'C' A: 'A' B: 'C' C: 'A' B: 'B' C: 'B'
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 3 C
A: 'B'
B: 'C'
C: 'A'
n: 1
RA: 4
A: 'A'
B: 'C'
C: 'B'
n: 2
RA: 2
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

17. Ablauf PC: 4 C A: 'B' A: 'A' B: 'C' A: 'A' B: 'C' C: 'A' B: 'B' C: 'B'
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 4 C
A: 'B'
B: 'C'
C: 'A'
n: 1
RA: 4
A: 'A'
B: 'C'
C: 'B'
n: 2
RA: 2
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

18. Ablauf PC: 4 C A: 'A' A: 'A' B: 'C' B: 'B' C: 'B' C: 'C' n: 2 n: 3
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 4 C
A: 'A'
B: 'C'
C: 'B'
n: 2
RA: 2
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

19. Ablauf PC: 2 C A: 'A' B: 'B' C: 'C' n: 3 RA: STOP B A
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 2 C
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

20. Ablauf PC: 3 C A: 'A' B: 'B' C: 'C' n: 3 RA: STOP B A
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 3 C
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

21. Ablauf PC: 1 C A: 'C' A: 'A' B: 'B' B: 'B' C: 'A' C: 'C' n: 2 n: 3
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 1 C
A: 'C'
B: 'B'
C: 'A'
n: 2
RA: 4
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

22. Ablauf PC: 1 C A: 'C' B: 'A' A: 'C' A: 'A' B: 'B' C: 'B' B: 'B' C: 'A'
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 1 C
A: 'C'
B: 'A'
C: 'B'
n: 1
RA: 2
A: 'C'
B: 'B'
C: 'A'
n: 2
RA: 4
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

23. Ablauf PC: 2 C A: 'C' B: 'A' A: 'C' A: 'A' B: 'B' C: 'B' B: 'B' C: 'A'
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 2 C
A: 'C'
B: 'A'
C: 'B'
n: 1
RA: 2
A: 'C'
B: 'B'
C: 'A'
n: 2
RA: 4
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

24. Ablauf PC: 3 C A: 'C' B: 'A' A: 'C' A: 'A' B: 'B' C: 'B' B: 'B' C: 'A'
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 3 C
A: 'C'
B: 'A'
C: 'B'
n: 1
RA: 2
A: 'C'
B: 'B'
C: 'A'
n: 2
RA: 4
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

25. Ablauf PC: 4 C A: 'C' B: 'A' A: 'C' A: 'A' B: 'B' C: 'B' B: 'B' C: 'A'
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 4 C
A: 'C'
B: 'A'
C: 'B'
n: 1
RA: 2
A: 'C'
B: 'B'
C: 'A'
n: 2
RA: 4
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

26. Ablauf PC: 2 C A: 'C' A: 'A' B: 'B' B: 'B' C: 'A' C: 'C' n: 2 n: 3
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 2 C
A: 'C'
B: 'B'
C: 'A'
n: 2
RA: 4
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

27. Ablauf PC: 3 C A: 'C' A: 'A' B: 'B' B: 'B' C: 'A' C: 'C' n: 2 n: 3
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 3 C
A: 'C'
B: 'B'
C: 'A'
n: 2
RA: 4
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

28. Ablauf PC: 1 C A: 'A' A: 'C' B: 'B' A: 'A' B: 'B' C: 'C' B: 'B' C: 'A'
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 1 C
A: 'A'
B: 'B'
C: 'C'
n: 1
RA: 4
A: 'C'
B: 'B'
C: 'A'
n: 2
RA: 4
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

29. Ablauf PC: 2 C A: 'A' A: 'C' B: 'B' A: 'A' B: 'B' C: 'C' B: 'B' C: 'A'
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 2 C
A: 'A'
B: 'B'
C: 'C'
n: 1
RA: 4
A: 'C'
B: 'B'
C: 'A'
n: 2
RA: 4
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

30. Ablauf PC: 3 C A: 'A' A: 'C' B: 'B' A: 'A' B: 'B' C: 'C' B: 'B' C: 'A'
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 3 C
A: 'A'
B: 'B'
C: 'C'
n: 1
RA: 4
A: 'C'
B: 'B'
C: 'A'
n: 2
RA: 4
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

31. Ablauf PC: 4 C A: 'A' A: 'C' B: 'B' A: 'A' B: 'B' C: 'C' B: 'B' C: 'A'
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 4 C
A: 'A'
B: 'B'
C: 'C'
n: 1
RA: 4
A: 'C'
B: 'B'
C: 'A'
n: 2
RA: 4
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

32. Ablauf PC: 4 C A: 'C' A: 'A' B: 'B' B: 'B' C: 'A' C: 'C' n: 2 n: 3
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 4 C
A: 'C'
B: 'B'
C: 'A'
n: 2
RA: 4
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

33. Ablauf PC: 4 C A: 'A' B: 'B' C: 'C' n: 3 RA: STOP B A
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: 4 C
A: 'A'
B: 'B'
C: 'C'
n: 3
RA: STOP A B

34. Ablauf PC: STOP C Das war's B A
void move(char A, char B, char C, int n){
1: if(n>1) move(A, C, B, n-1);
2: printf("%5d:%c ---> %c\n", n, A, B);
3: if (n>1) move(C, B, A, n-1); 4: }
PC: STOP C
Das war's A B

35. So sieht die Sache jetzt ausB C

36. Ende des Foliensatzes