汉诺塔的非递归算法

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

问题描述

将一个柱子中的所有圆盘移动到另一个柱子，移动过程需遵守以下规则：每次只能移动一个圆盘，而且只能移动某个柱子上最顶部的圆盘；移动过程中，必须保证每个柱子上的大圆盘都位于小圆盘的下面。

递归算法

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

#include<iostream>
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个盘子

步骤	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;
}

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