PTA 数据结构与算法 7-17 汉诺塔的非递归实现

如有不对，不吝赐教
进入正题：
借助堆栈以非递归（循环）方式求解汉诺塔的问题（n, a, b, c），即将N个盘子从起始柱（标记为“a”）通过借助柱（标记为“b”）移动到目标柱（标记为“c”），并保证每个移动符合汉诺塔问题的要求。

输入格式:
输入为一个正整数N，即起始柱上的盘数。

输出格式:
每个操作（移动）占一行，按柱1 -> 柱2的格式输出。

输入样例:
3

输出样例:
a -> c
a -> b
c -> b
a -> c
b -> a
b -> c
a -> c

这个题目要求我们用反常规的思维去思考汉诺塔问题，其实是对自己思维的一个锻炼，
这个题目的关键是用堆去实现函数递归中的栈调用
下面就以3个为例来分析
我们把从下到上的编号为3,2,1
以及栈的构造：

typedef struct Stack{
int num;            //柱子的编号
char source;        //源
char destination;   //目标
char mid;           //中间的柱子
struct Stack *down;
}stack;

下面我们将塔看为最底下的一个盘（即3）并上面的所有盘作为一个盘（即2和1），那么问题变为了两个盘，这个移动就很简单了。
我们先把1,2盘移动到b，再把3移动到c，最后再把1,2盘移动到c

这在栈里面的操作就是 Push 3：a->c
为了将3移动出来，我们要把1,2放到b，于是问题就变成了怎么把1,2放到b，按照上面的分发，栈中的操作就是Push 2：a->b，然后就变成了怎么把1放到c，执行Push：a->c
代码就是：

top=(stack *)malloc(sizeof(stack));
top->down=NULL;
top->source='a';
top->mid='b';
top->destination='c';
top->num=N;                  //初始化第一个栈节点

i=N-1;
while(i){
top=Push(i,top->source,top->destination,top->mid,top);
i--;
}

现在栈中的状态就是这样的：

然后我们要开始执行操作，Pop就相当于执行栈顶的操作
Pop 1:a->c后，stack和汉诺塔变成：

然后就是执行Pop 2：a->b，根据前面的分析，在执行这个操作后，1,2盘应该到了b上面但实际上是这样的：

所以我们还得在Pop完后在向其中把1盘放回b，即：Push 1：c->b
然后stack变成了这样：

这一步的操作就是这样的：

result=Pop(&top);
printf("%c -> %c\n",result->source,result->destination);
i=result->num-1;
if(!i)
continue;
stack *newOne;
newOne=(stack *)malloc(sizeof(stack));
newOne->num=i--;
newOne->source=result->mid;
newOne->mid=result->source;
newOne->destination=result->destination;
newOne->down=top;
top=newOne;
free(result);
while(i){
top=Push(i,top->source,top->destination,top->mid,top);
i--;
}
}

然后在进行Pop 1：c->b操作，就成了这样：

然后就是一样的操作，就可以把3放到c，1,2放到了b，于是问题就变成了把1,2从b放到c
问题就得以简化了
下面给出代码：

#include<stdio.h>
#include<malloc.h>

typedef struct Stack{
int num;            //柱子的编号
char source;        //源
char destination;   //目标
char mid;           //中间的柱子
struct Stack *down;
}stack;
stack *Push(int num,char source,char mid,char destination,stack *top);
stack *Pop(stack **top);

int main(void)
{
int N,i;
stack *top;
stack *result;
scanf("%d",&N);

top=(stack *)malloc(sizeof(stack));
top->down=NULL;
top->source='a';
top->mid='b';
top->destination='c';
top->num=N;                  //初始化第一个栈节点

i=N-1;
while(i){
top=Push(i,top->source,top->destination,top->mid,top);
i--;
}

while(top){
result=Pop(&top);
printf("%c -> %c\n",result->source,result->destination);
i=result->num-1;
if(!i)
continue;
stack *newOne;
newOne=(stack *)malloc(sizeof(stack));
newOne->num=i--;
newOne->source=result->mid;
newOne->mid=result->source;
newOne->destination=result->destination;
newOne->down=top;
top=newOne;
free(result);
while(i){
top=Push(i,top->source,top->destination,top->mid,top);
i--;
}
}

return 0;
}

stack *Push(int num,char source,char mid,char destination,stack *top)
{
stack *newOne;
newOne=(stack *)malloc(sizeof(stack));

newOne->num=num;
newOne->down=top;
newOne->source=source;                    //重置三个柱子
newOne->mid=mid;
newOne->destination=destination;
top=newOne;

return top;
}

stack *Pop(stack **top)
{
stack *mid;

mid=*top;
*top=(*top)->down;

return mid;
}

测试结果:

至于正确性，可以画图看下