采用递归和非递归方法求解汉诺塔问题

递归：



#include<stdio.h>
void move(int n, int x, int y){
        printf("the %dth plate from %c to %c\n",n,x+65,y+65);
}
void hanoi(int n, int A, int B, int C){
        if(n==1)
            move(n,A,C);
        else{
            hanoi(n-1,A,C,B);
            move(n,A,C);
            hanoi(n-1,B,A,C);
        }
}
int main()
{
    int n;
    printf("Assuming the top plate is the first plate\nplease input the number of plate : ");
    scanf("%d",&n);
    hanoi(n,0,1,2);
}

非递归：#include <stdio.h>
#include <malloc.h>
#define MaxSize 100
void Hanoi1(int n,char a,char b,char c)
{
 if (n==1)
  printf("\t将第%d个盘片从%c移动到%c\n",n,a,c);
    else
 {
  Hanoi1(n-1,a,c,b);
  printf("\t将第%d个盘片从%c移动到%c\n",n,a,c);
  Hanoi1(n-1,b,a,c);
 }
}

typedef struct
{ int n;
 char x,y,z;
 bool flag;
} ElemType;
typedef struct
{ ElemType data[MaxSize];
 int top;
} StackType;

void InitStack(StackType *&s)   //初始化栈
{ s=(StackType *)malloc(sizeof(StackType));
 s->top=-1;
}
void DestroyStack(StackType *&s)  //销毁栈
{
 free(s);
}
bool StackEmpty(StackType *s)   //判断栈是否为空
{
 return(s->top==-1);
}
bool Push(StackType *&s,ElemType e)  //进栈
{ if (s->top==MaxSize-1)
  return false;
 s->top++;
 s->data[s->top]=e;
 return true;
}
bool Pop(StackType *&s,ElemType &e)  //出栈
{ if (s->top==-1)
  return false;
 e=s->data[s->top];
 s->top--;
 return true;
}
bool GetTop(StackType *s,ElemType &e)  //取栈顶元素
{ if (s->top==-1)
  return false;
 e=s->data[s->top];
 return true;
}
//----------------------------------------------------
void Hanoi2(int n, char x, char y, char z)
{ StackType *st;       //定义顺序栈指针
 ElemType e,e1,e2,e3;
 if (n<=0) return;      //参数错误时直接返回
 InitStack(st);       //初始化栈
 e.n=n; e.x=x; e.y=y; e.z=z; e.flag=false;
 Push(st,e);        //元素e进栈
 while (!StackEmpty(st))     //栈不空循环
 { Pop(st,e);       //出栈元素e
  if (e.flag==false)     //当不能直接移动盘片时
  {
   e1.n=e.n-1; e1.x=e.y; e1.y=e.x; e1.z=e.z;
   if (e1.n==1)     //只有一个盘片时可直接移动
    e1.flag=true;
   else       //有一个以上盘片时不能直接移动
    e1.flag=false;
   Push(st,e1);     //处理Hanoi(n-1,y,x,z)步骤
   e2.n=e.n; e2.x=e.x; e2.y=e.y; e2.z=e.z; e2.flag=true;
   Push(st,e2);     //处理move(n,x,z)步骤
   e3.n=e.n-1; e3.x=e.x; e3.y=e.z; e3.z=e.y;
   if (e3.n==1)     //只有一个盘片时可直接移动
    e3.flag=true;
   else
    e3.flag=false;    //有一个以上盘片时不能直接移动
   Push(st,e3);     //处理Hanoi(n-1,x,z,y)步骤
  }
  else        //当可以直接移动时
   printf("\t将第%d个盘片从%c移动到%c\n",e.n,e.x,e.z);
 }
 DestroyStack(st);      //销毁栈
}

int main()
{
 int n=3;
 printf("递归算法：%d个盘片移动过程:\n",n);
 Hanoi1(n,'X','Y','Z');
 printf("非递归算法：%d个盘片移动过程:\n",n);
 Hanoi2(n,'X','Y','Z');
 return 1;
}