【要求：】

1、假设圆盘最大数量为10，其余输入格式要求同前

2、要求打印初始状态下，起始圆柱拥有的圆盘数及每个圆盘的编号，在随后的每个移动步骤中，打印移动完成后每个圆柱的现有的圆盘数及编号（效果如下图）

3、从初始行开始，每行的具体输出格式要求（下图为10层的部分步骤）

【一些输出格式的细节要求：】

（1）步数宽度为4，右对齐，再多一个空格到“步”

（2）（）内为当前移动的盘号，宽度为2，右对齐

（3）ABC柱内容打印时，每个数字间一个空格，ABC间宽度预留正好10个数字+空格

（4）所有空白均为空格，不是其他符号（例：“初始:”和“A”之间数多个空格）

（5）输出行数过多，可以用输出重定向方式进行检查

（6）打印时，每行必须完整地从左到右输出，不允许采用之前的gotoxy之类的函数改变光标位置，也不允许使用退格键

（7）如果屏幕宽度过小，不足以容纳一行，则需要调整cmd窗口的宽度（具体方法参考之前的文档）

4、要求使用递归方式完成，为了在各层递归中共用变量，本题允许使用全局变量，具体要求为两种方式，不准违规多使用全局变量

（1）用三个全局简单变量表示三个栈顶指针、三个全局一维数组来记录三根圆柱中的圆盘数及编号、一个计数用的全局变量

（2）用一个全局一维数组（大小为[3]）、一个全局二维数组（大小为[3][10]）来记录三根圆柱中的圆盘数及编号、一个计数用的全局变量

5、递归函数不允许使用循环

6、数组初始化、打印横向数组、处理输出错误等均允许增加自用函数且允许使用循环

参考代码

#include <bits/stdc++.h> //包含万能头文件
using namespace std;     //使用命名空间std
int total, id_a, id_b, id_c;
int asd_a[15], asd_b[15], asd_c[15];
void print()
{
    int kongge;
    cout << "A:";
    for(int i=1; i<=id_a; ++i){
        cout << right << setw(2) << asd_a[i];
    }
    kongge=id_a*2;
    for(int i=kongge+1; i<=21; ++i){
        cout << " ";
    }
    cout << "B:";
    for(int i=1; i<=id_b; ++i){
        cout << right << setw(2) << asd_b[i];
    }
    kongge=id_b*2;
    for(int i=kongge+1; i<=21; ++i){
        cout << " ";
    }
    cout << "C:";
    for(int i=1; i<=id_c; ++i){
        cout << right << setw(2) << asd_c[i];
    }
    cout << endl;
}
//nn阶的汉诺塔，从from移动到to上，temp是辅助
void hannuota(int nn, char from, char temp, char to)
{
    if(nn==1){
        total++;
        cout << "第" << right << setw(4) << total << " 步";
        if(from=='A'){
            cout << "(" << right << setw(2) << asd_a[id_a] << "): ";
        }
        else if(from=='B'){
            cout << "(" << right << setw(2) << asd_b[id_b] << "): ";
        }
        else if(from=='C'){
            cout << "(" << right << setw(2) << asd_c[id_c] << "): ";
        }
        cout << from << "-->" << to << " ";
        if(from=='A' && to=='B'){
            id_b++;
            asd_b[id_b]=asd_a[id_a];
            id_a--;
        }
        else if(from=='A' && to=='C'){
            id_c++;
            asd_c[id_c]=asd_a[id_a];
            id_a--;
        }
        else if(from=='B' && to=='A'){
            id_a++;
            asd_a[id_a]=asd_b[id_b];
            id_b--;
        }
        else if(from=='B' && to=='C'){
            id_c++;
            asd_c[id_c]=asd_b[id_b];
            id_b--;
        }
        else if(from=='C' && to=='A'){
            id_a++;
            asd_a[id_a]=asd_c[id_c];
            id_c--;
        }
        else if(from=='C' && to=='B'){
            id_b++;
            asd_b[id_b]=asd_c[id_c];
            id_c--;
        }
        print();
    }
    else{
        hannuota(nn-1, from, to, temp);
        hannuota(1, from, temp, to);
        hannuota(nn-1, temp, from, to);
    }
}
int main()  //定义一个主函数
{
    int n;
    char start, end, mid;
    cout << "请输入汉诺塔的层数(1-10)：" << endl;
    cin >> n;
    cout << "请输入起始柱(A-C)：" << endl;
    cin >> start;
    cout << "请输入目标柱(A-C)：" << endl;
    cin >> end;
    if(start!='A' && end!='A'){
        mid='A';
    }
    else if(start!='B' && end!='B'){
        mid='B';
    }
    else{
        mid='C';
    }
    if(start=='A'){
        id_a=n;
        for(int i=1; i<=n; ++i){
            asd_a[i]=n-i+1;
        }
    }
    else if(start=='B'){
        id_b=n;
        for(int i=1; i<=n; ++i){
            asd_b[i]=n-i+1;
        }
    }
    else if(start=='C'){
        id_c=n;
        for(int i=1; i<=n; ++i){
            asd_c[i]=n-i+1;
        }
    }
    cout << "初始:                ";
    print();
    hannuota(n, start, mid, end);
    return 0;
}