n阶汉诺塔问题

最新推荐文章于 2022-03-01 22:54:29 发布
最新推荐文章于 2022-03-01 22:54:29 发布
阅读量2.2k 收藏 7
点赞数 6
文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46237604/article/details/115256244
版权
本文详细介绍了汉诺塔问题的解决策略，包括使用递归和栈两种方法。通过实例展示了3阶汉诺塔的移动过程，并提供了C语言实现的源代码。递归解法中，通过将最大碟子移动到目标塔，再移动剩余碟子，最终完成所有碟子的转移。栈方法则利用了栈的特性来模拟汉诺塔的移动过程。
摘要由CSDN通过智能技术生成

问题描述

        在汉诺塔(Towers of Hanoi)问题中，假设有n个碟子和3座塔。初始时所有碟子从大到小堆在塔x上，我们要把所有碟子都移动到塔z上，每次移动一个，而且任何时候都不能把大碟子压在小碟子的上面。

求解策略

之前用数组的思想求解，之后又补上用栈的思想求解，源码放在数组方法源码的前面

        递归。
        为了把最大的碟子移到塔3的底部，必须把其余n-1个碟子移动到塔2，然后把最大的碟子移动到塔3。接下来是把塔2上的n-1个碟子移动到塔c。为此可以利用塔1和塔3。可以完全忽略塔3上的已有的一个碟子，因为我们已经把最大的碟子移到塔3，在它顶上可以堆放任何一个碟子。
        下面用n=3时来模拟求解过程。
        初始时：
在这里插入图片描述
        我们想把三个碟子都移动到塔3，首先要把上面两个碟子看成一个整体，移动到塔2：
在这里插入图片描述
        那么如何把上面两个碟子移动到塔3碟子的上面？首先要把塔2的第一个碟子移到塔1：
在这里插入图片描述
        下面一步一步的模拟过程，以下是核心算法：

void Move(int id, TowerOfHanoi *a, TowerOfHanoi *b) {
    //将编号为n的圆盘从塔盘a移至b
    int i;
    if (Find(id, a) == FALSE) {
        printf("编号为%d的圆盘不在塔盘上\n", id);
        return;
    }
    if (a->disk[0] != id) {
        printf("编号为%d的圆盘不在塔顶，无法操作\n", id);
        return;
    }
    for (i = 0; i < a->count - 1; i++) {
        //移动塔盘a上的圆盘
        a->disk[i] = a->disk[i + 1];
    }
    for (i = b->count - 1; i >= 0; i--) {
        //移动塔盘b上的圆盘
        b->disk[i + 1] = b->disk[i];
    }
    b->disk[0] = id;
    a->count--;
    b->count++;
    Step++;//每移动一步，步数加一
}

void Hanoi(int n, TowerOfHanoi *x, TowerOfHanoi *y, TowerOfHanoi *z, int order) {
    //将x塔座上编号为1到n的盘子移动到塔座z上，y为中转站
    if (n == 1) {
        Move(n, x, z);
        PrintHanoi(x, y, z, order);
    } else {
        Hanoi(n - 1, x, z, y, order);
        Move(n, x, z);
        PrintHanoi(x, y, z, order);
        Hanoi(n - 1, y, x, z, order);
    }
}

        第一步：
在这里插入图片描述
        第二步：
在这里插入图片描述
        第三步：
在这里插入图片描述
        第四步：
在这里插入图片描述
        第五步：
在这里插入图片描述
        第六步：
在这里插入图片描述
        第七步：
在这里插入图片描述

下面是源代码，求解n阶汉诺塔问题（C语言实现）：

用堆栈的方法不会像用数组的方法可视化出来了，希望有大佬指点

栈：

源代码：
#include <stdio.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0

typedef int Status;//表示函数返回状态
typedef int ElementType;//表示元素类型
typedef struct {
    ElementType *top;//栈顶指针
    ElementType *base;
    ElementType stack_size;//当前已分配的存储空间，以元素为单位
    char name;//记录塔盘名字
} StackHanoi;
static int Step = 0;//记录步数

Status CreatStackHanoi(StackHanoi *x, StackHanoi *y, StackHanoi *z, ElementType order);//初始化栈x，y，z
ElementType Length(StackHanoi s);//返回栈的元素个数
ElementType GetTop(StackHanoi s);//返回栈顶元素的值
Status Push(StackHanoi *s, ElementType t);//入栈操作，成功返回OK，否则返回ERROR
Status Pop(StackHanoi *s);//出栈，删除栈顶元素
Status Hanoi(ElementType n, ElementType order, StackHanoi *x, StackHanoi *y, StackHanoi *z);//将编号为1到n的圆盘从塔x移动到塔z，塔y做辅助塔
Status Move(StackHanoi *a, ElementType id, StackHanoi *b);//将编号为id的圆盘从塔a移动到塔b
void PrintHanoi(StackHanoi x, StackHanoi y, StackHanoi z);//输出汉诺塔x，y，z
Status Find(StackHanoi s, ElementType id);//查询编号为id的圆盘是否再塔盘s上，是返回TRUE，否则返回FALSE


int main() {
    int order;//汉诺塔阶数
    scanf("%d", &order);
    StackHanoi x, y, z;//塔盘x，y，z
    CreatStackHanoi(&x, &y, &z, order);
    PrintHanoi(x, y, z);
    Hanoi(order, order, &x, &y, &z);
    return 0;
}

Status CreatStackHanoi(StackHanoi *x, StackHanoi *y, StackHanoi *z, ElementType order) {
    //初始化栈x，y，z
    x->base = (ElementType *) malloc(sizeof(ElementType) * (order + 1));
    y->base = (ElementType *) malloc(sizeof(ElementType) * (order + 1));
    z->base = (ElementType *) malloc(sizeof(ElementType) * (order + 1));
    if (!x->base && !y->base && !z->base) return ERROR;
    int i;
    x->top = x->base;
    y->top = y->base;
    z->top = z->base;
    x->stack_size = y->stack_size = z->stack_size = order;
    x->name = 'X';
    y->name = 'Y';
    z->name = 'Z';
    for (i = order; i > 0; i--) {
        //将圆盘堆叠在塔盘x上
        Push(x, i);
    }
    return OK;
}

ElementType Length(StackHanoi s) {
    //返回栈的元素个数
    return s.top - s.base;
}

ElementType GetTop(StackHanoi s) {
    //返回栈顶元素的值
    if (s.top == s.base) return ERROR;
    return *(s.top - 1);
}

Status Push(StackHanoi *s, ElementType t) {
    //入栈操作，成功返回OK，否则返回ERROR
    if (s->top - s->base >= s->stack_size) {
        //栈满，无法入栈
        printf("塔盘空间已满，无法再移入盘子\n");
        return ERROR;
    }
    *s->top = t;
    s->top++;
    return OK;
}

Status Pop(StackHanoi *s) {
    //出栈，删除栈顶元素
    if (s->top == s->base) {
        //栈空，没有可删除的栈顶元素
        printf("塔盘为空，没有可移走的圆盘\n");
        return ERROR;
    }
    s->top--;
    *s->top = -1;
    return OK;
}

Status Hanoi(ElementType n, ElementType order, StackHanoi *x, StackHanoi *y, StackHanoi *z) {
    //将编号为1到n的圆盘从塔x移动到塔z，塔y做辅助塔
    if (n == 1) {
        Move(x, n, z);
        PrintHanoi(*x, *y, *z);
    } else {
        Hanoi(n - 1, order, x, z, y);
        Move(x, n, z);
        PrintHanoi(*x, *y, *z);
        Hanoi(n - 1, order, y, x, z);
    }
    return OK;
}

Status Move(StackHanoi *a, ElementType id, StackHanoi *b) {
    //将编号为id的圆盘从塔a移动到塔b}
    if (Find(*a, id) == FALSE) {
        printf("编号为%d的圆盘不在塔盘上\n", id);
        return FALSE;
    }
    if (GetTop(*a) != id) {
        printf("编号为%d的圆盘不在塔顶，无法移动\n", id);
        return FALSE;
    }
    Push(b, id);
    Pop(a);
    Step++;
    return TRUE;
}

Status Find(StackHanoi s, ElementType id) {
    //查询编号为id的圆盘是否再塔盘s上，是返回TRUE，否则返回FALSE
    int length = Length(s);
    int i;
    for (i = 0; i < length; i++) {
        if (s.base[i] == id) {
            return TRUE;
        }
    }
    return FALSE;
}

void PrintHanoi(StackHanoi x, StackHanoi y, StackHanoi z) {
    //输出汉诺塔x，y，z
    printf("第%d步：\n", Step);
    printf("%c塔盘上的圆盘编号：", x.name);
    while (x.top != x.base) {
        printf("%d\t", GetTop(x));
        x.top--;
    }
    printf("\n%c塔盘上的圆盘编号：", y.name);
    while (y.top != y.base) {
        printf("%d\t", GetTop(y));
        y.top--;
    }
    printf("\n%c塔盘上的圆盘编号：", z.name);
    while (z.top != z.base) {
        printf("%d\t", GetTop(z));
        z.top--;
    }
    printf("\n");
}
输入n=3时，输出结果：

在这里插入图片描述在这里插入图片描述

数组：

递归过程中因为传参的问题让输出汉诺塔的时候塔的相对位置发生变化，结果没有问题

源代码
#include <stdio.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0

typedef int ElementType;//表示元素类型
typedef int Status;//表示函数返回状态
typedef struct {
    int count;//表示圆盘数量
    int *disk;//圆盘数组，用 disk[0] 表示塔顶
} TowerOfHanoi;
int Step = 0;//记录步数

void CreatHanoi(TowerOfHanoi *x, TowerOfHanoi *y, TowerOfHanoi *z, int n);//初始化汉诺塔x，y，z，汉诺塔阶数为n
void Move(int id, TowerOfHanoi *a, TowerOfHanoi *b);//将编号为id的圆盘从塔盘a移至b
Status Find(int id, TowerOfHanoi *t);//检测编号为id的圆盘是否在塔盘t上
void Hanoi(int n, TowerOfHanoi *x, TowerOfHanoi *y, TowerOfHanoi *z, int order);//将x塔座上编号为1到n的盘子移动到塔座z上，y为中转站
void PrintHanoi(TowerOfHanoi *x, TowerOfHanoi *y, TowerOfHanoi *z, int order);//输出汉诺塔

int main() {
    ElementType order;//存放汉诺塔阶数
    scanf("%d", &order);
    TowerOfHanoi x, y, z;
    CreatHanoi(&x, &y, &z, order);
    PrintHanoi(&x, &y, &z, order);
    Hanoi(order, &x, &y, &z, order);
    return 0;
}

void CreatHanoi(TowerOfHanoi *x, TowerOfHanoi *y, TowerOfHanoi *z, int n) {
    //初始化汉诺塔，将盘子堆到x塔盘上
    int i;
    x->count = n;
    y->count = z->count = 0;
    //为塔盘分配空间
    x->disk = (ElementType *) malloc(sizeof(int) * n);
    y->disk = (ElementType *) malloc(sizeof(int) * n);
    z->disk = (ElementType *) malloc(sizeof(int) * n);
    for (i = 0; i < n; i++) {
        x->disk[i] = i + 1;
        y->disk[i] = 0;
        z->disk[i] = 0;
    }
}

Status Find(int id, TowerOfHanoi *t) {
    //检测编号为id的圆盘是否在塔盘t上
    int i;
    for (i = 0; i < t->count; i++) {
        if (t->disk[i] == id)
            return TRUE;
    }
    return FALSE;
}

void Move(int id, TowerOfHanoi *a, TowerOfHanoi *b) {
    //将编号为n的圆盘从塔盘a移至b
    int i;
    if (Find(id, a) == FALSE) {
        printf("编号为%d的圆盘不在塔盘上\n", id);
        return;
    }
    if (a->disk[0] != id) {
        printf("编号为%d的圆盘不在塔顶，无法操作\n", id);
        return;
    }
    for (i = 0; i < a->count - 1; i++) {
        //移动塔盘a上的圆盘
        a->disk[i] = a->disk[i + 1];
    }
    for (i = b->count - 1; i >= 0; i--) {
        //移动塔盘b上的圆盘
        b->disk[i + 1] = b->disk[i];
    }
    b->disk[0] = id;
    a->count--;
    b->count++;
    Step++;//每移动一步，步数加一
}

void Hanoi(int n, TowerOfHanoi *x, TowerOfHanoi *y, TowerOfHanoi *z, int order) {
    //将x塔座上编号为1到n的盘子移动到塔座z上，y为中转站
    if (n == 1) {
        Move(n, x, z);
        PrintHanoi(x, y, z, order);
    } else {
        Hanoi(n - 1, x, z, y, order);
        Move(n, x, z);
        PrintHanoi(x, y, z, order);
        Hanoi(n - 1, y, x, z, order);
    }
}

void PrintHanoi(TowerOfHanoi *x, TowerOfHanoi *y, TowerOfHanoi *z, int order) {
    int i, j;
    printf("第%d步:\n", Step);
    for (i = 0; i < order; i++) {
        //控制行
        for (j = 0; j < order * 3 + 2; j++) {
            //控制列
            if (order - x->count <= i && x->disk[i - (order - x->count)] > j) {//输出x
                //判断能否打印并且打印的数量
                printf("=");
            } else {
                printf(" ");
            }
            if (order - y->count <= i && y->disk[i - (order - y->count)] >= j - order && j - order > 0) {//输出y
                //判断能否打印并且打印的数量
                printf("=");
            } else {
                printf(" ");
            }
            if (order - z->count <= i && z->disk[i - (order - z->count)] >= j - 2 * order && j - 2 * order > 0) {//输出z
                //判断能否打印并且打印的数量
                printf("=");
            } else {
                printf(" ");
            }
        }
        printf("\n");
    }
}
输入n=3时，输出结果：

在这里插入图片描述

tianxrrr
关注
  • 6
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
汉诺塔
nankeyimeng的博客
04-14 1491
问题 G 算法3-5：n阶Hanoi塔问题 时间限制: 1 Sec  内存限制: 128 MB [提交] 题目描述 假设有三个分别命名为X、Y和Z的塔座，在塔座X上插有n个直径大小各不相同、依小到大编号为1,2,...,n的圆盘。现要求将X轴上的n个圆盘移至塔座Z上并仍按同样顺序叠排，圆盘移动时必须遵循下列规则： 1）每次只能移动一个圆盘； 2）圆盘可以插在X、Y和Z中的任一塔
n阶汉诺塔问题（递归）
菜鸡成长史
06-21 1844
【汉诺塔】 汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说：大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。 【分析】 设A柱上原始盘子数量为n,则当n=1时，只需将盘子从A->C即可；否则 1.用...
n阶Hanoi塔问题（动图分析）-C语言
APP_xinyonghu_li的博客
03-01 1870
通过动图形象分析Hanoi塔问题
n阶汉诺塔问题（Hanoi）
anmang6285的博客
11-29 883
问题描述 假设有3个分别命名为X、Y、Z的塔座 在塔座X上插有n个直径大小各不相同、依小到大编号为1，2，...，n的圆盘。 现要求将X轴上的n个圆盘移至塔座Z上并仍按同样顺序叠排 圆盘移动时必须遵循下列规则： 每次只能移动一个圆盘 圆盘可以插在X、Y、Z中的任一塔座上 任何时刻都不能将一个较大的圆盘压在较小的圆盘之上 算法思想 当n=1时 问题比较简单，只要将编号为...
超简单容易理解的n阶汉诺塔问题
qq_43776544的博客
06-25 387
//n阶汉诺塔问题（递归算法） #include"stdio.h" void Hani(int n,char a,char b,char c)//通过c将n个盘子从a->b { if(n==1) { printf("%c->%c\n",a,b); } else { Hani(n-1,a,c,b);//先通过b将n-1个盘子从a->c printf("%c->%c\n",a,b);//再直接将最后一个盘子从a-&g
n阶汉诺塔问题 java
最新发布
11-08
以下是n阶汉诺塔问题的Java实现代码： ```java public class Hanoi { public static void main(String[] args) { Scanner s = new Scanner(System.in); System.out.println("请输入盘子数目"); int n = s....
用c语言用递归方法求解n阶汉诺塔问题
05-13
汉诺塔问题是一个经典的递归问题，下面是用C语言实现的递归方法。 ```c #include // n表示盘子的个数，A、B、C表示三个柱子 void hanoi(int n, char A, char B, char C) { if (n == 1) { printf("%c -> %c\n", ...
递归经典算法-汉诺塔问题求解-C/C++语言实现
皮皮昌的博客
06-11 630
问题： 古代有一个梵塔，塔内有3个基座A、B、C，开始时A基座上有64个盘子，盘子大小不等，大的在下，小的在上。有一个老和尚想把这64个盘子从A座移到B座，但每次只允许移动一个盘子，且在移动过程中在3个基座上的盘子都始终保持大盘在下，小盘在上。在移动过程中可以利用C基座做辅助。请编程打印出移动过程 。 分析 把n阶的汉诺塔问题的模块记作hanoi(n,a,b,c) a代表每一次移动的起始基座， b代表每一次移动的终点基座， c代表每一次移动的辅助基座 则汉诺塔问题hanoi(n,a,b,c)等价于以下三步：
C语言实现N阶汉诺塔
01-01
C语言实现汉诺塔，选择要实现的汉诺塔的阶数，程序将显示此阶汉诺塔的解
n阶汉诺塔源代码与演示程序
05-17
这是一个汉诺塔的演示程序，里面有源代码！适合实验使用，而且还有注释！
n阶汉诺塔（樊塔）问题 C语言简单实现状态空间法
MndBng的博客
10-06 2616
汉诺塔问题或者叫做樊塔问题： 有三个分别名为A，B，C的塔座，A上有n个直径大小个相同、由小到大编号为1，2，…，n的圆盘。将A上n个圆盘移至C上，移动时必须遵循： （1）每次只能移动一个圆盘 （2）圆盘可以插在A，B，C中的任意一个塔座上； （3）任何时刻不能将一个较大的圆盘压在较小的圆盘之上 很经典的递归问题，通过从2阶 3阶的移动方式 我们不难看出其总的方法要分为三步： 1， 把n-1个圆盘从A移动到B； 2， 把最大的圆盘n从A移动到C； 3， 把n-1个圆盘从B移动到C； 其中第二步是不可分的，所
C++| n阶汉诺塔问题(递归)
失心疯的博客
03-09 588
//the problem of Hanoi#include &lt;iostream&gt;using namespace std;void Move(int n, char x, char y){    cout&lt;&lt;"make "&lt;&lt;n&lt;&lt;" move to "&lt;&lt;y&lt;&lt;" from "&a
算法与设计实验1:N阶Hanoi塔问题
Chen_dSir的博客
12-11 3051
由于实验指导书上没有给出具体的问题描述，这里把ACM的算法描述列了出来: 问题: 假设有三个分别命名为X、Y和Z的塔座，在塔座X上插有n个直径大小各不相同、依小到大编号为1,2,...,n的圆盘。现要求将X轴上的n个圆盘移至塔座Z上并仍按同样顺序叠排，圆盘移动时必须遵循下列规则： 1）每次只能移动一个圆盘； 2）圆盘可以插在X、Y和Z中的任一塔座上； 3）任何时
n阶Hanoi塔
SuiGi的博客
07-11 328
/*思路如下: ①假定只有两个圆盘,执行到n==1,移动2-1盘到B，最下圆盘到C，再把B中的2-1盘移动到C ②假定有三个圆盘，①的步骤已执行，但由于Hanoi(2,A,C,B)传入顺序，最终结果是把2,1盘移动到了B上 然后执行Move(A,n,C),把3盘移动到C上,然后在把B上的3-1个盘当做①部A的两个圆盘移动到C上 以下同理循环执行*/ #include<stdio.h>...
C语言递归实现n阶汉诺塔操作过程
weixin_52104555的博客
01-30 3076
C语言递归实现n阶汉诺塔操作过程 汉诺塔（Tower of Hanoi）是一个源于印度古老传说的益智玩具。基本规则很简单，有三个立柱，然后在最左边放着n个盘子叠成的“塔”，要求把所有盘子移到最右边的柱子，一次只能移动一个盘子，并且不能从中间抽出盘子，即只能拿最上面的盘子，并且移动盘子过程中需始终遵循大盘子在小盘子下面的原则。 程序要求：已知三根柱子从左到右依次标号A、B、C。输入一个正整数n，表示最左边的柱子一开始盘子的个数，盘子初始状态也遵循大盘子在小盘子下面的原则，并且盘子从小到大依次标号为1、2、…、
求解n阶Hanoi塔问题的c函数
deason6975的专栏
05-11 845
#include int Count=0;void move(char x,int n,char z){ printf(" %d. disk %d: %c => %c/n",++Count,n,x,z);}//move// 将塔座x上按直径由小到大且自上而下编号为1至n的n个圆盘按规则搬到塔座z上，y可用作辅助塔座void Hanoi(int n,char x,char y,char z)
递归总结：八皇后问题（N皇后问题）、汉诺塔（N阶汉诺塔）、全排列问题
FFOYeah的博客
07-11 631
1.八皇后问题
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值