由来
法国数学家爱德华·卢卡斯曾编写过一个印度的古老传说:在世界中心贝拿勒斯(在印度北部)的圣庙里,一块黄铜板上插着三根宝石针。印度教的主神梵天在创造世界的时候,在其中一根针上从下到上地穿好了由大到小的64片金片,这就是所谓的汉诺塔。不论白天黑夜,总有一个僧侣在按照下面的法则移动这些金片:一次只移动一片,不管在哪根针上,小片必须在大片上面。僧侣们预言,当所有的金片都从梵天穿好的那根针上移到另外一根针上时,世界就将在一声霹雳中消灭,而梵塔、庙宇和众生也都将同归于尽。
设计思想
对于汉诺塔问题的求解,可以通过以下三个步骤实现:
- 将塔A上的n-1个碟子借助塔C先移到塔B上。
- 把塔A上剩下的一个碟子移到塔C上。
- 将n-1个碟子从塔B借助塔A移到塔C上。
主要代码
这里我们要介绍的源码有两种,一种是C++递归的算法,一种是C++非递归的算法。
递归
void Hanoi(int n ,char A, char B, char C) {
if (n == 1) {
cout<<A<<"-->"<<C<<endl;
} else {
Hanoi(n-1, A ,C ,B);
cout<<A<<"-->"<<C<<endl;
Hanoi(n-1, B ,A ,C);
}
}
首先,我先解释以下这个函数的意思:
函数的声明定义为:
|-- n是总的盘子的个数
|-- A,B,C的这三个参数的含义就是将盘子从A [借助B] 移动到C上去
|-- Hanoi(n-1, A ,C ,B);这种形式的时候就是这样子的
|-- Hanoi(n-1, B ,A ,C);这种表示将盘子从B [借助A] 移动到C上去
|-- 假设为3
|-- 第一次需要将最上面一层移动到C上
|-- 第二次需要将次一层移动到B上
|-- 这里两次是类似栈的,先进后出,
|-- 先调用一次Hanoi(n-1, A ,C ,B);这可以看成是栈底元素
|-- 再调用一次Hanoi(n-1, A ,C ,B);这可以看成是栈顶元素
|-- 到达底部的时候(n==1),这里就开始“出栈”了,所以输出顺序是A->C,A->B。
|-- A->C这里n==1 ,所以进入了if (n == 1) {cout<<A<<"-->"<<C<<endl;}中
|-- A->B这里n==2 ,所以进入了else中,输出else中的cout<<A<<"-->"<<C<<endl;中
|-- 之后就执行Hanoi(n-1, B ,A ,C); , 执行的情况类是于上述,一直到n==1
|-- 总的来说,就是树状图的形式进行运行的,首先
|-- 从主函数调用进入
|-- 这里有两条路
|-- Hanoi(n-1, A ,C ,B); ----(1)
|-- Hanoi(n-1, B ,A ,C); ----(2)
|-- 这里我们先执行第(1)句,执行到n==1的时候就行了,就开始回调
|-- 在回调的过程中我们就调用第(2)句。
当然,这个过程是很难理解的,所以我附上一张图,当n=3的时候的运行过程:
按照箭头,每次执行完一块就
这里附上描述:
首先是调用
Hanoi(n-1, A ,C ,B);
这一句,
大致过程:
- 3,A,B,C
- 2,A,C,B
- 1,A,B,C
直到n==1的时候,就调用
cout<<A<<"-->"<<C<<endl;
这一句,
- 输出A->C
调用完后就开始回调,
执行else块中
Hanoi(n-1, A ,C ,B);
下面的语句,
- 输出A->B
- 执行Hanoi(n-1, B ,A ,C);
- n = 1,所以输出C->B
- 执行完之后,又是一波回调,当前n=3
- 输出A->C
- 执行Hanoi(n-1, B ,A ,C);
- n=2,所以执行了Hanoi(n-1, A ,C ,B);
- 输出B->A
- 回调后输出B->C
- 执行Hanoi(n-1, B ,A ,C);
- 最后输出了A->C
执行完毕。
至此,通过不断的回调获得最终的答案。
以下是完整的代码:
# include <iostream>
# include <cstdlib>
using namespace std;
void Hanoi(int n ,char A, char B, char C) {
if (n == 1) {
cout<<"n = "<<n<<","<<A<<"-->"<<C<<endl;
} else {
Hanoi(n-1, A ,C ,B);
cout<<"n = "<<n<<","<<A<<"-->"<<C<<endl;
Hanoi(n-1, B ,A ,C);
}
}
int main()
{
Hanoi(3,'A','B','C');
system ("pause");
return 0;
}
/*
n = 1,A-->C
n = 2,A-->B
n = 1,C-->B
n = 3,A-->C
n = 1,B-->A
n = 2,B-->C
n = 1,A-->C
请按任意键继续. . .
*/
非递归
非递归主要是通过找出汉诺塔的规律来实现算法的。
首先,我们先把3个那个什么东东 —.—围成一圈。
嗯,重点来了。
我们在移动盘子的时候都是这样子挪动的——A->B,B->C,C->A,A->C,B->A,C->B。所以我们定义顺时针为0,逆时针为1。同时通过细细分析,我们还可以发现,盘子的移动是有一定的规律的。
- 当顺时针的时候,单单存在A->B,B->C,C->A。
- 当逆时针的时候,单单存在A->C,B->A,C->B。
因此,我们定义了
char order[2][256];
order[0]['A'] = 'B';
order[0]['B'] = 'C';
order[0]['C'] = 'A';
order[1]['A'] = 'C';
order[1]['B'] = 'A';
order[1]['C'] = 'B';
之后,我们需要分析它在运行过程中要怎么判断他的方向问题的:
n = 3
times = 1,direction = 1 : A --> C
times = 2,direction = 0 : A --> B
times = 3,direction = 1 : C --> B
times = 4,direction = 1 : A --> C
times = 5,direction = 1 : B --> A
times = 6,direction = 0 : B --> C
times = 7,direction = 1 : A --> C
从上面的数据可以直观的看出:当times为奇数(m%2!=0)的时候,方向(direction)都为1(逆序)。但是,偶数就不是这么好处理了。
n = 3
times = 2,direction = 0 : A --> B
times = 4,direction = 1 : A --> C
times = 6,direction = 0 : B --> C
有点奇怪,是吧~~我当时是一脸懵逼的。T.T
有个巧妙的方法可以解决,如下:
- times = 2,times%2可以连续取余数1次
- times = 4,times%2可以连续取余数2次
- times = 6,times%2可以连续取余数1次
O了,可以了。
之后,当我们用n=4的时候,会发现
times = 1,direction = 1 : A --> B// 这里
times = 2,direction = 0 : A --> C
times = 3,direction = 1 : B --> C
times = 4,direction = 1 : A --> B
times = 5,direction = 1 : C --> A
times = 6,direction = 0 : C --> B
times = 7,direction = 1 : A --> B
times = 8,direction = 0 : A --> C
times = 9,direction = 1 : B --> C
times = 10,direction = 0 : B --> A
times = 11,direction = 1 : C --> A
times = 12,direction = 1 : B --> C
times = 13,direction = 1 : A --> B
times = 14,direction = 0 : A --> C
times = 15,direction = 1 : B --> C
与我们之前定义的的方向是不符合的,如下:
char order[2][256];
order[0]['A'] = 'B';
order[0]['B'] = 'C';
order[0]['C'] = 'A';
order[1]['A'] = 'C';
order[1]['B'] = 'A';
order[1]['C'] = 'B';
A->B的时候方向是0而不是1,所以我们需要加个判断n是偶数还是奇数的机制。
//0是顺序 1是逆序
int index[2];
if (n%2 == 0) {
index[1] = 0;
index[0] = 1;
} else {
index[1] = 1;
index[0] = 0;
}
最后:附上总的代码
#include <iostream>
#include <memory.h>
using namespace std;
void Hanoi(char src, char des, char via, int n)
{
if(n == 1)
{
cout << n <<" : "<< src <<" --> " <<des << endl;
return;
}
Hanoi(src, via, des, n - 1);
cout << n <<" : "<< src <<" --> " <<des << endl;
Hanoi(via, des, src, n - 1);
}
int main()
{
int n;
cin >> n;
cout<<"recusive:"<< endl;
Hanoi('A','C','B', n);
cout << endl;
cout<<"normal:"<<endl;
char order[2][256];
char pos[64];
order[0]['A'] = 'B';
order[0]['B'] = 'C';
order[0]['C'] = 'A';
order[1]['A'] = 'C';
order[1]['B'] = 'A';
order[1]['C'] = 'B';
//确定轨迹的顺序还是逆序
int i, j, m;
//0是顺序 1是逆序
int index[2];
if (n%2 == 0) {
index[1] = 0;
index[0] = 1;
} else {
index[1] = 1;
index[0] = 0;
}
memset(pos, 'A', sizeof(pos));
// 总共运行了2^n-1(也就是1<<n)次
for(i = 1; i < (1 << n); i ++) {
for(m = 1, j = i; j%2 == 0; j/=2, m ++) {
;
}
cout <<"times = "<<i<<",direction = "<<m%2<<" : "<< pos[m] <<" --> " << order[index[m%2]][pos[m]] << endl;
pos[m] = order[index[m%2]][pos[m]];
}
return 0;
}
/*
3
recusive:
1 : A --> C
2 : A --> B
1 : C --> B
3 : A --> C
1 : B --> A
2 : B --> C
1 : A --> C
normal:
times = 1,direction = 1 : A --> C
times = 2,direction = 0 : A --> B
times = 3,direction = 1 : C --> B
times = 4,direction = 1 : A --> C
times = 5,direction = 1 : B --> A
times = 6,direction = 0 : B --> C
times = 7,direction = 1 : A --> C
请按任意键继续. . .
*/