c语言循环加数组实现汉诺塔问题

 更新时间:2022年01月28日 10:29:52   作者:用户882121311605lv-1  
本文主要介绍了c语言循环加数组实现汉诺塔问题,文中通过示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

简介

汉诺塔问题是学数据结构与算法的时候会遇到的问题,相信来看本文的读者应该都对汉诺塔问题有基本的了解,理论上所有的递归都可以改成循环,常规的做法是借助堆栈,但是我一想好像用循环加数组也可以实现,于是就有了本文,实现声明,本文最后出来的算法效率不高的,比直接用递归实现还要差很多,追求算法效率的同学就不用看这个了。
题目:假设有3个柱子,分别为A、B、C,A柱子上有数量为n个的空心圆盘,从上到下序号分别为1...n,要求把A柱子中的n个圆盘移动到C柱中,且序号大的盘子必须在在需要小的圆盘下方。
思路:如果只有1个圆盘需要移动,则直接从A柱移动到C柱,如果有n个圆盘(n>1)需要移动,则需要先把n-1个圆盘从A柱移动到B柱,再把第n个圆盘从A柱移动到C柱,最后把原来的n-1个圆盘从B柱移动到C柱。

例如:

将1个圆盘从A柱移动到C柱只需要1个步骤:

1. 把圆盘1从A移动到C

将2个圆盘从A柱移动到C柱需要3个步骤:

1. 把圆盘1从A移动到B
2. 把圆盘2从A移动到C
3. 把圆盘1从B移动到C

将3个圆盘从A柱移动到C柱需要7个步骤:

1. 把圆盘1从A移动到C
2. 把圆盘2从A移动到B
3. 把圆盘1从C移动到B
4. 把圆盘3从A移动到C
5. 把圆盘1从B移动到A
6. 把圆盘2从B移动到C
7. 把圆盘1从A移动到C

递归的汉诺塔解法(c语言)

可以看出下面的递归算法的时间复杂度为O(2^n),因为存在有调用2^n-2次递归调用和1次原生printf;而空间复杂度为O(n),因为运行时栈中最多会同时保存n个函数的调用信息。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

void towers(int n, char from, char to, char aux);
int main() {
    towers(3, 'A', 'C', 'B');
    return 0;
}

void showMove (int order, char from, char to) {
    printf("move disk %d from %c to %c\n", order, from, to);
}

void towers(int n, char from, char to, char aux) {
    if (n==1) {
        showMove(n, from, to);
        return;
    }
    towers(n-1, from, aux, to);
        showMove(n, from, to);
    towers(n-1, aux, to, from);
}

解释一下代码中参数的含义,void towers(int n, char from, char to, char aux)的意思是把n个圆盘从from柱子移动到to柱子,中间可以借用aux柱子。

分析一下上面的递归执行过程:

我们已经知道把1个圆盘从from移动到to的步骤是showMove(1, from, to);

而把2个圆盘从from移动到to的步骤是,先照着移动1个圆盘的操作,把前面1个圆盘从from移动到aux,再把第2个圆盘从from移动到to,最后按照移动1个圆盘的操作,把刚才的1个圆盘从aux移动到to。

同理,把3个圆盘从from移动到to的步骤是,先照着移动2个圆盘的操作,把前面2个圆盘从from移动到aux,再把第3个圆盘从from移动到to,最后按照移动2个圆盘的操作,把刚才的2个圆盘从aux移动到to。

所以,把n个圆盘的操作从from移动到to的步骤是,先照着移动n-1个圆盘的操作,把前面n-1个圆盘从from移动到aux,再把第n个圆盘从from移动到to,最后按照移动n-1个圆盘的操作,把刚才的n-1个圆盘从aux移动到to。

因此,我们可以记录移动1个圆盘的步骤,来得到移动2个圆盘的步骤,通过移动2个圆盘的步骤来得到移动3个圆盘的步骤,...最后得到移动n个圆盘的步骤。经过分析可以知道移动n个圆盘一共会有2^n-1个步骤

循环实现汉诺塔问题(c语言)

为了代码更加易懂,这里写了注释,修改了部分变量命名,统一用数组保存步骤集合,最后才输出。
可以看出这个算法的时间复杂度还是O(2^n),一共会执行2^(n+1)-1次setMoveAction语句和2^n-1次,printf语句,比起直接用递归还要复杂一些,而空间复杂度也是O(2^n),属于没什么用的算法,就是随便写写。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

void towers(int n, char from, char to, char aux);
int main()
{
    towers(3, 'A', 'C', 'B');
    return 0;
}

void showMove(int order, char from, char to)
{
    printf("move disk %d from %c to %c\n", order, from, to);
}

typedef struct
{
    int order;
    char from;
    char to;
} MoveAction;

void setMoveAction(MoveAction *p, int order, char from, char to)
{
    p->order = order;
    p->from = from;
    p->to = to;
}

char compare_map(char c, char left, char right) {
    if (c == left) {
        return right;
    } else if (c == right) {
        return left;
    }
    return c;
}

void towers(int n, char from, char to, char aux)
{
    MoveAction *actions, action;
    int i, k, size;
    char f, t;

    actions = (MoveAction *)calloc(pow(2, n - 1) - 1, sizeof(MoveAction));
    setMoveAction(&actions[0], 1, from, to);
    size = 1;

    for (i = 2; i <= n; i++)
    {
        //本次循环会将把i个盘子从from移动到to的步骤记录到actions数组中
        // 设size是把i-1个盘子从from移动到to的步骤数,
        // 则本次循环中集合{actions[x] | 0 <= x <= size -1 }就是size是把i-1个盘子从from移动到aux的步骤集合,
        //而action[size]是把第i个盘子从from移到to,
        //而集合{actions[x] | size + 1 <= x <= 2*size }就应该是把i-1个盘存从aux移动到to的步骤集合

        // 倒序,先求解集合{actions[x] | size + 1 <= x <= 2*size }
        for (k = 0; k < size; k++)
        {
            action = actions[k];
            f = compare_map(action.from, from, aux);
            t = compare_map(action.to, from, aux);
            setMoveAction(&actions[k + size + 1], action.order, f, t);
        }
        // 求解action[size]
        setMoveAction(&actions[size], i, from, to);
        // 求解集合{actions[x] | 0 <= x <= size -1 }
        for (k = 0; k < size; k++)
        {
            action = actions[k];
            f = compare_map(action.from, to, aux);
            t = compare_map(action.to, to, aux);
            setMoveAction(&actions[k], action.order, f, t);
        }
        size = size * 2 + 1;
    }

    for (i = 0; i < size; i++)
    {
        showMove(actions[i].order, actions[i].from, actions[i].to);
    }
}

到此这篇关于c语言循环加数组实现汉诺塔问题的文章就介绍到这了,更多相关c语言 汉诺塔内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • 深入理解C语言中编译相关的常见错误

    深入理解C语言中编译相关的常见错误

    本篇文章是对C语言中编译相关的常见错误进行了详细的分析介绍,需要的朋友参考下
    2013-05-05
  • 提升编程能力的C语言技巧总结

    提升编程能力的C语言技巧总结

    这篇文章主要为大家总结了一些C语言技巧的相关资料,可以帮助大家大大提升编程能力。文中的示例代码讲解详细,感兴趣的小伙伴可以了解一下
    2022-12-12
  • opencv4.5.4+VS2022开发环境搭建的实现

    opencv4.5.4+VS2022开发环境搭建的实现

    本文主要介绍了opencv4.5.4+VS2022开发环境搭建的实现,文中通过示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2022-02-02
  • C语言实现职工管理系统

    C语言实现职工管理系统

    这篇文章主要为大家详细介绍了C语言实现职工管理系统,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2019-11-11
  • 去掉vs2010中ipch文件和.sdf文件的解决方法

    去掉vs2010中ipch文件和.sdf文件的解决方法

    本篇文章介绍了,在vs2010中产生的ipch文件和.sdf文件的解决方法。需要的朋友参考下
    2013-05-05
  • C/C++字符串函数之复制函数详解

    C/C++字符串函数之复制函数详解

    下面小编就为大家带来一篇C/C++字符串函数之复制函数详解。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
    2016-09-09
  • 解析C++中临时对象的产生情况

    解析C++中临时对象的产生情况

    临时对象的产生和销毁都是有成本的,都会影响程序的执行性能和效率,所以如果能了解临时对象产生的原因,就可以提升程序的性能和效率,下面小编就来和大家聊聊临时对象产生的几种情况吧
    2023-06-06
  • C++实现学校人员管理系统

    C++实现学校人员管理系统

    这篇文章主要为大家详细介绍了C++实现学校人员管理系统,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2022-03-03
  • Dev C++中文乱码的有效解决方案

    Dev C++中文乱码的有效解决方案

    在DevC++中出现汉字乱码的问题通常是由于编码设置不正确导致的,本文通过图文结合的方式给大家介绍了解决方法,对大家的解决问题有一定的帮助,需要的朋友可以参考下
    2025-04-04
  • C++ string替换单个指定字符为其它字符问题

    C++ string替换单个指定字符为其它字符问题

    这篇文章主要介绍了C++ string替换单个指定字符为其它字符问题,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2023-06-06

最新评论