汉诺塔的非递归实现（C++/C）

C++就用到了传引用的知识点，其他的都是C的

问题分析

汉诺塔实现的基本思路是：不断将n个盘的汉诺塔问题转换为2个n-1个盘的汉诺塔问题，因此用递归实现是很自然的方法。当把n盘问题转换为n-1盘问题时，问题的起始柱子和目标柱子也发生了变化。设n盘问题为（n, a, b, c），其中参数如实验内容中所定义，则问题的求解可转换为对（n-1, a, e, b）、（1, a, b, c）、（n-1, b, a, c）这三个问题的求解，其中（1, a, b, c）不需要递归，可直接实现。

在要求不用递归的情况下，可以借助自己建立的堆栈来解决问题。将待求解问题放入堆栈，然后不断将栈顶的问题分解，再将分解出的n > 1的新问题放入堆栈，如此不断循环一直到堆栈为空，问题求解就可结束。

注意：当将分解出的上述三个问题压入堆栈时，应该按照“需要先求解的问题后压入”的顺序，也就是压入顺序为：（n-1, b, a, c）、（1, a, b, c）、（n-1, a, c, b）。

（2）实现要点

①堆栈元素的数据结构：根据问题的要求，可将堆栈元素类型ElementType定义为一个结构体，存放待求解的问题，即包含盘数n起始柱a、借助柱b、目标柱c的结构。

②设计不断求解堆栈中问题的循环结构。其基本算法过程是：

将初始问题（n，a，b，c）放入堆栈

 

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100
typedef struct{
	int n;
	char x,y,z;
	bool flag;
}ElemType;
typedef struct{
	ElemType data[MAXSIZE];
	int top;
}StackType;
void initial(StackType*&p){
	p=(StackType*)malloc(sizeof(StackType));
	p->top=-1;
}
void push(StackType*&p,ElemType e){
	p->top++;
	p->data[p->top]=e;
}
void pop(StackType*&p,ElemType &e){
	e=p->data[p->top];
	p->top--;
}
int Empty(StackType*p){
	return p->top==-1?1:0;
}
void hanoi(int n,char x,char y,char z){
	StackType*p;
	ElemType e,e1,e2,e3;
	initial(p);
	e.n =n;
	e.x =x;
	e.y =y;
	e.z =z;
	if(e.n ==1)
	e.flag =true;
	else
	e.flag =false;
	push(p,e);
	while(!Empty(p)){
		pop(p,e);
		if(e.flag ==false){
			if(e.n-1==1)
			e1.flag =true;
			else
			e1.flag =false;
			e1.n =e.n -1;e1.x =e.y ;e1.y =e.x ;e1.z =e.z ;
			push(p,e1);
			e2.flag =true;e2.n =n;e2.x =e.x ;e2.y =e.y ;e2.z =e.z ;//e2执行的是move步骤，所以标记为true 
			push(p,e2);
			e3.flag =e1.flag;e3.n =e.n -1;e3.x =e.x ;e3.y =e.z ;e3.z =e.y ;
			push(p,e3);
		}
		else
		printf("%c->%c\t",e.x ,e.z );
	}
	free(p);
}
int main(){
	int n=0;
	char x='x';
	char y='y';
	char z='z';
	while(n<=0){
	printf("请输入要移动的盘的个数;\n");
	scanf("%d",&n);}
	hanoi(n,x,y,z);
	return 0;
}