【无标题】

对于汉诺塔问题,我们都普遍认为这个是一个典型的递归问题,然而递归需要使用到系统对应的栈,开销比较大,因此我在想使用非递归算法来解决它,然而网上绝大部分的教程都是自己模拟了一个栈,因此我在考虑写一篇blog记录一下。

问题描述

将一个柱子中的所有圆盘移动到另一个柱子,移动过程需遵守以下规则:每次只能移动一个圆盘,而且只能移动某个柱子上最顶部的圆盘;移动过程中,必须保证每个柱子上的大圆盘都位于小圆盘的下面。
【无标题】_第1张图片

递归算法

这个算法还算比较好理解,我们计A,B,C盘,那么假设我们要把n圆盘,从A移到C,可以拆分为小问题,我们把上面n-1个的圆盘看成整体,让它先到B,那么最下面的一个移动到C,再把n-1个从B移动到C。
这样就把复杂问题,拆分成更简单的问题,那么退出条件就是只剩下一个圆盘,即为,A->C

#include
using namespace std;
//算法设计实验1,汉诺塔问题
//采用递归方法解决
//n个棋盘  A B C为基座   最终达成目标A全部移到C
//性能 T(n)=2T(n-1)+1  1忽略 那么时间复杂度为O(2^n),相当的大,因此对于n较大的时候,运行时间较长
void Hanoi1(int n,char A,char B,char C)
{
	if (n == 1)
	{
		cout  << A << " -> "<< C << endl;
		return;
	}
	Hanoi1(n - 1, A, C, B);//相当于先把上面n-1盘子,移到中间
	cout<< A << " -> " << C << endl;
	Hanoi1(n - 1, B, A, C);//相当于先把上面n-1盘子,移到中间
}
int main()
{
	int n;
	cout << "请选择汉诺塔层数:";
	cin >> n;
	//递归算法
	Hanoi1(n, 'A', 'B', 'C');
	return 0;
}

【无标题】_第2张图片

非递归算法

当然我参考的时候发现,很多人模拟了栈作为非递归算法,这种当然可以,但是其核心思想还是用栈的方法,实现递归,本质上和系统的栈思想一致。因此我在考虑用真正非递归的思想来解决这个问题。
由于问题较为复杂,因此咱们先举出比较简单的例子。
假设只有2个盘子
【无标题】_第3张图片

步骤 1 2 3 4 5 6 7
移动的盘子 0 1 0 2 0 1 0
步骤 0->2 0->1 2->1 0->2 1->0 1->2 0->2

我们可以发现其中是有规律的:

  1. 如果把三个柱子围成一个环,盘子总数为N,
  2. 如果N为偶数:奇数号盘每次2步;偶数号盘每次1步;
  3. 如果N为奇数:奇数号盘每次1步;偶数号盘每次2步;
  4. 当三个柱子都不为空则优先移动最小的盘子。
#define N 150
#define X dish[i].dnum
#define Y dish[i].lnum
#define SP dish[i].peg
//向右走一步
struct dish
{
	int dnum;	//自身编号
	int lnum;	//下面的盘子
	int peg;	//所在的柱子
}dish[N];
//初始化每个柱的状态为空
int s[3] = {};
//向右走一步
int mov1(int sp, int x)
{
	if (s[(sp + 1) % 3] > x)//要移动的目标是可以承载当前盘子的
	{
		//printf("\nmove1\n");
		printf("%d %d --> %d\n", x, sp, (sp + 1) % 3);
		s[dish[x].peg] = dish[x].lnum; //x盘所在柱子减去当前盘,顶盘变为x盘的下一个
		dish[x].lnum = s[(dish[x].peg + 1) % 3]; //x盘的落点即x转移后的下面的盘
		s[(dish[x].peg + 1) % 3] = dish[x].dnum; //x盘转移到的柱子顶盘值变为x盘值
		dish[x].peg = (dish[x].peg + 1) % 3; //x盘所在柱子变为落点柱子
		return 1; //转移成功
	}
	else return 0; //转移失败
}
//向右走两步
int mov2(int sp, int x)
{
	if (s[(sp + 2) % 3] > x)//要移动的目标是可以承载当前盘子的
	{
		//printf("\nmove2\n");
		printf("%d %d --> %d\n", x, sp, (sp + 2) % 3);
		s[dish[x].peg] = dish[x].lnum; //x盘所在柱子减去当前盘,顶盘变为x盘的下一个
		dish[x].lnum = s[(dish[x].peg + 2) % 3]; //x盘的落点即x转移后的下面的盘
		s[(dish[x].peg + 2) % 3] = dish[x].dnum; //x盘转移到的柱子顶盘值变为x盘值
		dish[x].peg = (dish[x].peg + 2) % 3; //x盘所在柱子变为落点柱子
		return 1; //转移成功
	}
	else return 0; //转移失败
}
int main()
{
	int n;
	cout << "请选择汉诺塔层数:";
	cin >> n;
	int i, change = 1, j;
	for (i = 0; i < n; i++)
	{
		dish[i].dnum = i; //作为盘子的唯一标识,顶层为0,最高级的最大盘子为N-1
		dish[i].lnum = i + 1; //底层盘子的下一层为N,即空柱
		dish[i].peg = 0; //初始化,所有盘子都在A柱	
	}
	s[0] = 0; //当前0柱上最顶端的盘子值
	s[1] = n;
	s[2] = n;//空柱,屏蔽大于n的盘子
	while (s[0] < n || s[1] < n)
	{
		j = 0;
		for (i = 0; s[j] <= n && i < n; i++) //不为空柱则向下找盘子
		{
			if (s[0] >= n && s[1] >= n)
				return;
			if (s[dish[i].peg] != dish[i].dnum) //当上面有盘子时不能移动
				continue;
			if ((n % 2 == 0 && X % 2 == 0) || (n % 2 == 1 && X % 2 == 1))
				change = mov1(SP, X);
			else change = mov2(SP, X);
			if (!change)
			{
				if (s[0] < n && s[1] < n && s[2] < n)
				{
					for (int k = 0; s[k] != 0; k++)
						j = k;
				}
				else j = (j + 1) % 3; //该柱上没有盘子可以移动则更换柱子
			}
		}
	}
	return 0;
}

因此可以得到非递归版本的,汉诺塔答案!

你可能感兴趣的:(算法,c++,开发语言)