题目
借助堆栈以非递归(循环)方式求解汉诺塔的问题(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
首先得对递归的解法有所了解。
void hanoi(int n,char A,char B,char C)
{
if(n==1)
printf("%c->%c",A,C) // 等价于hanoi(1,B,A,C)
else{
hanoi(n-1,A,C,B);
printf("%c->%c",A,C) // 等价于hanoi(1,B,A,C)
hanoi(n-1,B,A,C);
}
}
算法思路
当用非递归的方法求解时,将else语句里的三个子问题压入堆栈,按照“需要先求解的问题后压入”的顺序(因为栈的特性时先进后出,后压入的问题会被先求解),压入顺序为(n-1,b,a,c),(1,a,b,c),(n-1,a,c,b)。
将初始问题(n,a,b,c)放入堆栈中
while(堆栈非空)
{
Pop堆栈顶问题,假设是(n,a,b,c);
if(n==1)
printf a->c;
else{
Push(n-1,b,a,c);
Push(1,a,b,c);
Push(n-1,a,c,b);
}
}
栈的定义及相关函数
糗呀,create我拼错了!写成了creat了……
typedef struct {
char A;
char B;
char C;
int N;
} ElementType;
typedef struct stack {
ElementType *data;
int top;
} * Stack;
Stack creatStack() {
Stack stack;
stack = (Stack)malloc(sizeof(struct stack));
stack->data = (ElementType *)malloc(maxSize * sizeof(ElementType));
stack->top = -1;
return stack;
}
int isEmpty(Stack stack) {
return stack->top == -1;
}
void push(Stack stack, ElementType data) {
stack->data[++(stack->top)] = data;
}
ElementType pop(Stack stack) {
return stack->data[(stack->top)--];
}
核心函数hanoi(int N)
void hanoi(int N) {
// P为当前待解决的汉诺塔问题,toPush为当前问题的子问题
ElementType P, toPush;
Stack stack = creatStack();
P.N = N;
P.A = 'a';
P.B = 'b';
P.C = 'c';
// 要解决的汉诺塔问题入栈
push(stack, P);
while (!isEmpty(stack)) {
//每次先解决栈顶的汉诺塔问题
P = pop(stack);
// N为1时就不再分解为子问题,直接输出
if (P.N == 1) {
printf("%c->%c\n", P.A, P.C);
} else {
//子问题2:把N-1的部分由借助柱B转移至目标柱C,对应递归解法的 hanoi(n-1,B,A,C)
toPush.N = P.N - 1;
toPush.A = P.B;
toPush.B = P.A;
toPush.C = P.C;
// 子问题2入栈
push(stack, toPush);
// N为1时直接输出,对应递归解法的 hanoi(1,B,A,C),也就是printf("%c->%c",A,C)(注:这里的A、C是递归解法里的参数A、C)
toPush.N = 1;
toPush.A = P.A;
toPush.B = P.B;
toPush.C = P.C;
// 令这个可直接求解的子问题入栈
push(stack, toPush);
// //子问题1:把N-1的部分由起始柱A转移至借助柱B,对应递归解法的hanoi(n-1,A,C,B)
toPush.N = P.N - 1;
toPush.A = P.A;
toPush.B = P.C;
toPush.C = P.B;
// 子问题1入栈
push(stack, toPush);
}
}
}
全部代码
#include <stdio.h>
#define maxSize 64
typedef struct {
char A;
char B;
char C;
int N;
} ElementType;
typedef struct stack {
ElementType *data;
int top;
} * Stack;
void hanoi(int N);
Stack creatStack();
int isEmpty(Stack stack);
void push(Stack stack, ElementType data);
ElementType pop(Stack stack);
int main() {
int N;
scanf("%d", &N);
hanoi(N);
return 0;
}
void hanoi(int N) {
// P为当前待解决的汉诺塔问题,toPush为当前问题的子问题
ElementType P, toPush;
Stack stack = creatStack();
P.N = N;
P.A = 'a';
P.B = 'b';
P.C = 'c';
// 要解决的汉诺塔问题入栈
push(stack, P);
while (!isEmpty(stack)) {
//每次先解决栈顶的汉诺塔问题
P = pop(stack);
// N为1时就不再分解为子问题,直接输出
if (P.N == 1) {
printf("%c -> %c\n", P.A, P.C);
} else {
//子问题2:把N-1的部分由借助柱B转移至目标柱C,对应递归解法的 hanoi(n-1,B,A,C)
toPush.N = P.N - 1;
toPush.A = P.B;
toPush.B = P.A;
toPush.C = P.C;
// 子问题2入栈
push(stack, toPush);
// N为1时直接输出,对应递归解法的 hanoi(1,B,A,C),也就是printf("%c->%c",A,C)(注:这里的A、C是递归解法里的参数A、C)
toPush.N = 1;
toPush.A = P.A;
toPush.B = P.B;
toPush.C = P.C;
// 令这个可直接求解的子问题入栈
push(stack, toPush);
// //子问题1:把N-1的部分由起始柱A转移至借助柱B,对应递归解法的hanoi(n-1,A,C,B)
toPush.N = P.N - 1;
toPush.A = P.A;
toPush.B = P.C;
toPush.C = P.B;
// 子问题1入栈
push(stack, toPush);
}
}
}
Stack creatStack() {
Stack stack;
stack = (Stack)malloc(sizeof(struct stack));
stack->data = (ElementType *)malloc(maxSize * sizeof(ElementType));
stack->top = -1;
return stack;
}
int isEmpty(Stack stack) {
return stack->top == -1;
}
void push(Stack stack, ElementType data) {
stack->data[++(stack->top)] = data;
}
ElementType pop(Stack stack) {
return stack->data[(stack->top)--];
}
后话
maxSize
在这题应当大于32,否则会报段错误,但是应该也不用64这么大,大家可以试着找到合适的大小,减少开销。
代码写得比较顺利,但是我在处理子问题1那一步出了错。
toPush.N = P.N - 1;
这一句代码我把P.N
误写成N
,导致子问题一直入栈,指针top
都飙到了300多,最后报了段错误。