漢諾塔遞歸思維

漢諾塔比較經典的實現是利用遞歸，但也可以利用堆棧。

題意理解：有A,B,C三個柱子，將A柱子上的N個盤子（從大到小排列）移到C柱子上，每次只允許移動一個盤子，並且保證每個柱子上的盤子的排列都是從大到小。

1、遞歸實現

　　假設只有一個盤子，那么只需實現 A->C 這個動作；

　　如果有兩個盤子，那么需要

　　(1)A->B;

　　(2)A->C;

　　(3)B->C;

　　如果有三個盤子，可以將前兩個盤子看作一個盤子，對兩個盤子重復以上三個步驟，於是得到N個盤子的遞歸算法，遞歸結束的條件是N=1；

　　

 1 void Hanoi(int n,char A,char B,char C)  //A借助B,將n個盤子移到C ,遞歸的妙用在於不用關心具體實現的細節
 2 {
 3     if (n==1)printf("%c -> %c",A,C); //只有一個盤子，直接將其移到C
 4     else
 5     {
 6         Hanoi(n-1,A,C,B);  //第一步，A借助C，將n-1個盤子移到B;
 7         printf("%c -> %c",A,C);   //第二步，將A上剩余的一個盤移到C;
 8         Hanoi(n-1,B,A,C)  //第三步，將B上的n-1個盤子移到C。
 9     }
10 }

 

　　可以用人腦來模擬一下該過程：

　　當有三個盤子時，在主函數中調用Hanoi（3，A，B，C）時，進入函數中執行else后的一句，Hanoi（2，A，C，B），並且在棧中為后續語句分配空間但不執行。接着再調用自身，Hanoi（1，A，B，C），輸出A->C;函數開始“歸”，即執行調用Hanoi（1，A，B，C）函數之后未執行的語句，“第二步”，由於這是在函數Hanoi（2，A，C，B），故輸出A->B;接着調用Hanoi（1，C，A，B），輸出C->B;接着“歸”，此時回到函數Hanoi（3，A，B，C），輸出A->C;接着調用函數Hanoi（2，B，A，C），在調用Hanoi（1，B，C，A）輸出B->A;接着輸出B->C;最后，調用Hanoi（1，A，B，C）輸出A->C.

 

------------------------------------------------------------------------------------------------------------------------------------------------------

 

 以下是利用堆棧實現非遞歸：

1 #include<stdio.h>
 2 #include<stdlib.h>
 3 #include<stdbool.h>
 4 typedef struct Problem{
 5     int n;
 6     char src,mid,dest;
 7     struct Problem *Next;
 8 }Stack;
 9 
10 Stack *CreateStack()
11 {
12     Stack *S;
13     S=(Stack*)malloc(sizeof(struct Problem));
14     S->Next=NULL;
15     return S;
16 }
17 
18 bool IsEmpty(Stack *S)
19 {
20     return (S->Next==NULL);
21 }
22 
23 void Push(Stack *S,int n,char A,char B,char C)
24 {
25     Stack *TmpCell;
26     TmpCell=(Stack *)malloc(sizeof(struct Problem));
27     TmpCell->n=n;
28     TmpCell->src=A;
29     TmpCell->mid=B;
30     TmpCell->dest=C;
31     TmpCell->Next=S->Next;
32     S->Next=TmpCell;
33 }
34 
35 Stack *Pop(Stack *S,Stack *curPrb)
36 {
37     Stack *FirstCell;
38     FirstCell=(Stack *)malloc(sizeof(struct Problem));
39     FirstCell=S->Next;
40     curPrb->n=FirstCell->n;curPrb->src=FirstCell->src;curPrb->mid=FirstCell->mid;curPrb->dest=FirstCell->dest;
41     S->Next=FirstCell->Next;
42     free(FirstCell);
43     return curPrb;
44 }
45 
46 int main()
47 {
48     int n;
49     scanf("%d",&n);
50     Stack *S;
51     S=CreateStack();
52     Push(S,n,'A','B','C');
53     while (!IsEmpty(S))
54     {
55         Stack *curPrb;
56         curPrb=(Stack *)malloc(sizeof(struct Problem));
57         curPrb=Pop(S,curPrb);
58         if (curPrb->n==1)printf("%c -> %c\n",curPrb->src,curPrb->dest);
59         else
60         {
61             Push(S,curPrb->n-1,curPrb->mid,curPrb->src,curPrb->dest);//堆棧的順序和遞歸正好相反
62             Push(S,1,curPrb->src,curPrb->mid,curPrb->dest);
63             Push(S,curPrb->n-1,curPrb->src,curPrb->dest,curPrb->mid);
64         }
65         free(curPrb);
66     }
67     free(S);
68     return 0;
69 }