习题3.10 汉诺塔的非递归实现 (25分)

问题描述
借助堆栈以非递归（循环）方式求解汉诺塔的问题（n, a, b, c），即将N个盘子从起始柱（标记为“a”）通过借助柱（标记为“b”）移动到目标柱（标记为“c”），并保证每个移动符合汉诺塔问题的要求。
输入
输入为一个正整数N，即起始柱上的盘数。
输出
每个操作（移动）占一行，按柱1 -> 柱2的格式输出。

问题分析
汉诺塔的基本思路是不断将n个盘的汉诺塔问题转换为2个n-1的问题，用递归实现，当把n盘问题转换成n-1盘问题时，问题的起始柱和目标柱都发生了变化，设n盘问题为(n,a,b,c),其中参数如实验内容定义，则问题转换为（n-1,a,c,b）,(1,a,b,c),(n-1,b,a,c)这三个问题，其中（1,a,b,c）不需要递归，按顺序压入堆栈

递归

void hanoi(int n,char A,char B,char C)
{
	if(n==1)
	move(A,C);
	else
	{
	hanoi(n-1,A,C,B);
	move(A,C);
	hanoi(n-1,B,A,C);
	}
}

非递归
当将分解出的上述三个问题压入堆栈时，按照“需要先求解的问题后压入”的顺序，压入顺序为(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);
	}
}

程序设计步骤

1.主函数设计

int main()
{
    int n;
    scanf("%d",&n);
    Hanoi(n);//借助堆栈的非递归实现
    return 0;
}

2.需要设计的函数

void Push(Stack *PtrS, ElementType item);//入栈
ElementType Pop(Stack *PtrS);//出栈
void Hanoi(int n);//迭代解决并输出
可以也可以不用设计判断栈空的函数

2.1入栈和出栈的函数

void Push(Stack *PtrS, ElementType item)
{
    PtrS->Data[++(PtrS->Top)] = item;
}
ElementType Pop(Stack *PtrS){
    PtrS->Top--;
    return(PtrS->Data[PtrS->Top+1]);
}

2.2hanoi

void Hanoi(int n){
    ElementType P, toPush;//P为当前待解决的汉诺塔问题（随迭代规模递减）,toPush为当前问题的子问题（N-1和1，其中N-1又分为两步）
    Stack S;
    P.N = n; P.A = 'a'; P.B = 'b'; P.C = 'c';
    S.Top = -1;
    Push(&S, P);
    while(S.Top!=-1){
        P = Pop(&S);//每次解决栈顶问题，根据先进后出原则，每个问题的子问题1应最后入栈
        if(P.N==1) printf("%c -> %c\n",P.A, P.C);//N为1便无须分解为子问题
        else{
            toPush.N = P.N - 1;
            toPush.A = P.B; toPush.B = P.A; toPush.C = P.C;//子问题2：把N-1的部分由借助柱转移至目标柱
            Push(&S, toPush);//子问题2入栈
            toPush.N = 1;
            toPush.A = P.A; toPush.B = P.B; toPush.C = P.C;//规模为1时可直接解决
            Push(&S, toPush);//可直接求解的子问题入栈
            toPush.N = P.N - 1;
            toPush.A = P.A; toPush.B = P.C; toPush.C = P.B;//子问题1：把N-1的部分由起始柱转移至借助柱
            Push(&S, toPush);//子问题1入栈
        }
    }
}

2.3汉诺塔类型的结构类型定义和栈的定义

typedef struct{//汉诺塔问题结构类型
    int N;//盘数
    char A;//起始柱
    char B;//借助柱
    char C;//目标柱
} ElementType;
typedef struct{//栈的标准定义
    ElementType Data[MaxSize];
    int Top;
}Stack;

3总代码

#include<stdio.h>
#define MaxSize 100

typedef struct{//汉诺塔问题结构类型
    int N;//盘数
    char A;//起始柱
    char B;//借助柱
    char C;//目标柱
} ElementType;
typedef struct{//栈的标准定义
    ElementType Data[MaxSize];
    int Top;
}Stack;
void Push(Stack *PtrS, ElementType item);//入栈
ElementType Pop(Stack *PtrS);//出栈
void Hanoi(int n);//迭代解决并输出

int main()
{
    int n;
    scanf("%d",&n);
    Hanoi(n);
    return 0;
}

void Hanoi(int n){
    ElementType P, toPush;//P为当前待解决的汉诺塔问题（随迭代规模递减）,toPush为当前问题的子问题（N-1和1，其中N-1又分为两步）
    Stack S;
    P.N = n; P.A = 'a'; P.B = 'b'; P.C = 'c';
    S.Top = -1;
    Push(&S, P);
    while(S.Top!=-1){
        P = Pop(&S);//每次解决栈顶问题，根据先进后出原则，每个问题的子问题1应最后入栈
        if(P.N==1) printf("%c -> %c\n",P.A, P.C);//N为1便无须分解为子问题
        else{
            toPush.N = P.N - 1;
            toPush.A = P.B; toPush.B = P.A; toPush.C = P.C;//子问题2：把N-1的部分由借助柱转移至目标柱
            Push(&S, toPush);//子问题2入栈
            toPush.N = 1;
            toPush.A = P.A; toPush.B = P.B; toPush.C = P.C;//规模为1时可直接解决
            Push(&S, toPush);//可直接求解的子问题入栈
            toPush.N = P.N - 1;
            toPush.A = P.A; toPush.B = P.C; toPush.C = P.B;//子问题1：把N-1的部分由起始柱转移至借助柱
            Push(&S, toPush);//子问题1入栈
        }
    }
}

void Push(Stack *PtrS, ElementType item){
    PtrS->Data[++(PtrS->Top)] = item;
    return;
}
ElementType Pop(Stack *PtrS){
    PtrS->Top--;
    return(PtrS->Data[PtrS->Top+1]);
}

to be countine…