C++汉诺塔

由来

---

法国数学家爱德华·卢卡斯曾编写过一个印度的古老传说：在世界中心贝拿勒斯（在印度北部）的圣庙里，一块黄铜板上插着三根宝石针。印度教的主神梵天在创造世界的时候，在其中一根针上从下到上地穿好了由大到小的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
请按任意键继续. . .
*/