c语言汉诺塔递归算法转非递归,汉诺塔问题非递归算法-C

该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

/*

网上看到别人发的关于汉诺塔问题非递归算法，每次都看得有点晕，今天又看了一次，终于明白了其实现原理

传统的递归方法效率极其低下，时间和空间复杂度均呈几何级数增长，当问题规模达到20时，计算时间很漫长，更不用谈30以后的了，

所以，寻找一种非递归方法就很有必要了。

下面是笔者刚刚完成的c++算法

*/

#include

#include

using namespace std;

char pan[3]={'A','B','C'};//三根柱子

int zhuzi[3];//三根柱子的状态

int num;//盘子数

int bu;//总步数 //接受用户输入，并初始化数据

void input(){

cout<

cin>>num;

bu=zhuzi[0]=(int)pow(2,num)-1;

if(num%2==1){

pan[1]='C';

pan[2]='B';

}

}//输出结果

void output(char x,char y){

cout<"<

}//移动盘子

void move(bool x){

//x=1则将第一个盘子移动到下一根柱子上,否则把另外两根柱子上可以移动的圆盘移动到新的柱子上。

//先计算出第一个盘子的位置

int one;

int m,n,t,a,b;

for(int i=0;i<3;i++){

if(zhuzi[i]%2==1){

one=i;

break;

}

}

if(x){

if(one!=2){

zhuzi[one+1]+=1;

output(pan[one],pan[one+1]);

}else{

zhuzi[0]+=1;

output(pan[one],pan[0]);

}

zhuzi[one]-=1;

}else{

switch(one){

case 0:

a=zhuzi[1];

b=zhuzi[2];

t=0;

while(1){

a/=2;

b/=2;

t++;

if(a%2==1){

m=1;

break;

}

if(b%2==1){

m=2;

break;

}

}

n=(int)pow(2,t);

zhuzi[m]-=n;

zhuzi[3-m]+=n;

output(pan[m],pan[3-m]);

break;

case 1:

a=zhuzi[0];

b=zhuzi[2];

t=0;

while(1){

a/=2;

b/=2;

t++;

if(a%2==1){

m=0;

break;

}

if(b%2==1){

m=2;

break;

}

}

n=(int)pow(2,t);

zhuzi[m]-=n;

zhuzi[2-m]+=n;

output(pan[m],pan[2-m]);

break;

case 2:

a=zhuzi[0];

b=zhuzi[1];

t=0;

while(1){

a/=2;

b/=2;

t++;

if(a%2==1){

m=0;

break;

}

if(b%2==1){

m=1;

break;

}

}

n=(int)pow(2,t);

zhuzi[m]-=n;

zhuzi[1-m]+=n;

output(pan[m],pan[1-m]);

break;

}

}

}void fun(){

int t=0;

while(1){

if(t

move(1);

t++;

}else{

break;

}

if(t

move(0);

t++;

}else{

break;

}

}

cout<

}

int main(){

input();

fun();

}/*

理论上这种算法的时间效率相对于传统算法会大幅度提升，然而运行上面的程序，会发现并非如此，?

为什么呢？本程序中有大量的算术运算，这个是制约本程序时间效率的主要因素 ,如何减少运算时间，是接下来需要解决的问题。

解决了这个问题，才真正可以说它的时间效率比传统算法高很多

*/

傲世孤尘

2013-05-25