【补发】利用栈处理Hanoi塔问题——递归解决 数据结构严蔚敏

编译环境：Dev-C++
编程语言：C语言
Hanoi塔问题描述：（来自百度百科）
汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

教材P55中有更具体的描述和分析。在此不多说，直接看代码：

#include<stdio.h> 
#define N 6
#include<stdlib.h>
#include<malloc.h>
//函数结果状态代码
#define OK 1
#define ERROR 0
#define OVERFLOW -1

typedef int Status;
typedef int ElemType;
//栈的顺序存储表示
#define STACK_INIT_SIZE 10
#define STACKINCREMENT 5
typedef struct{
	ElemType *base;//基址，在栈构造之前和销毁之后，base的值为NULL 
	ElemType *top;//栈顶指针 
	int stacksize;//当前已分配的存储空间 
}SqStack; 
//构造一个空栈S
Status InitStack(SqStack *S)
{
	(*S).base=(ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType));
	if(!(*S).base) exit(OVERFLOW);
	(*S).top=(*S).base;
	(*S).stacksize=STACK_INIT_SIZE;
	return OK;
} 
//入栈（插入元素e为新的栈顶元素），前提S存在
Status Push(SqStack *S,ElemType e)
{
	if((*S).top-(*S).base>=(*S).stacksize)
	{
		(*S).base=(ElemType *)realloc((*S).base,((*S).stacksize+STACKINCREMENT)*sizeof(ElemType));
		if(!(*S).base) exit(OVERFLOW);
		(*S).top=(*S).base+(*S).stacksize;
		(*S).stacksize+=STACKINCREMENT;
	}
	*((*S).top++)=e;
	return OK;
}
//出栈（若栈不空，删除栈顶元素，并用e返回其值），前提S存在
Status Pop(SqStack *S,ElemType *e)
{
	if((*S).top==(*S).base) return ERROR;
	*e=*(--(*S).top);
	return OK;
}
//顺序栈的遍历：依次访问栈中每一个元素，前提S存在
Status StackTraverse(SqStack S)
{
	if(S.top==S.base) 
	    printf("栈为空！");
	else
	{
		int i=0;
		while(i<S.top-S.base)
		{
			printf("%d ",*(S.base+i));
			i++;
		}
	}
	printf("\n");
	return OK;
}

int e,m=0;//m用来记录移动的次数
SqStack S1,S2,S3;//全局变量 

void Print()
{
	StackTraverse(S1);
	StackTraverse(S2);
	StackTraverse(S3);
	printf("\n");	
}

void Hanoi13(int n)
{
	void Hanoi12(int n);
	void Hanoi23(int n);
	if(n>1)
		Hanoi12(n-1);
	Pop(&S1,&e);
	Push(&S3,e);
	printf("第%d次移动：\n",++m);
	Print();
	if(n>1)
		Hanoi23(n-1);
}

void Hanoi12(int n)
{
	void Hanoi32(int n);
	if(n>1)
		Hanoi13(n-1);
	Pop(&S1,&e);
	Push(&S2,e);
	printf("第%d次移动：\n",++m);
	Print();
	if(n>1)
		Hanoi32(n-1);
}

void Hanoi23(int n)
{
	void Hanoi21(int n);
	if(n>1)
		Hanoi21(n-1);
	Pop(&S2,&e);
	Push(&S3,e);
	printf("第%d次移动：\n",++m);
	Print();
	if(n>1)
		Hanoi13(n-1);
}

void Hanoi21(int n)
{
	void Hanoi31(int n);
	if(n>1)
		Hanoi23(n-1);
	Pop(&S2,&e);
	Push(&S1,e);
	printf("第%d次移动：\n",++m);
	Print();
	if(n>1)
		Hanoi31(n-1);
}

void Hanoi31(int n)
{
	void Hanoi32(int n);
	if(n>1)
		Hanoi32(n-1);
	Pop(&S3,&e);
	Push(&S1,e);
	printf("第%d次移动：\n",++m);
	Print();
	if(n>1)
		Hanoi21(n-1);
}

void Hanoi32(int n)
{
	if(n>1)
		Hanoi31(n-1);
	Pop(&S3,&e);
	Push(&S2,e);
	printf("第%d次移动：\n",++m);
	Print();
	if(n>1)
		Hanoi12(n-1);
}

int main()
{
	InitStack(&S1);
	InitStack(&S2);
	InitStack(&S3);
	int i;
	for(i=N;i>0;i--)
	{
		Push(&S1,i);
	}
	printf("初始状态：\n");
	Print();
	Hanoi13(N);//从S1转移到S3 
	return 0;
}

N为6的运行结果：


由于每次移动都是有规律的，易知：
f(1)=1;
f(2)=3;
f(n)=2*f(n-1)+1;
故：
f(n)=2^n-1;

再来看看N为16的结果：

若令N为64，嗯…我能活到运行结束的时候吗？