汉诺塔的非递归实现

借助堆栈以非递归（循环）方式求解汉诺塔的问题（n，a，b，c）。即将n个盘子从起始柱(标记为“a”)通过借助柱（标记为“b”)移动到目标杜(标记为“c”)，并保证每个移动符合汉诺塔问题的要求。
在这里插入图片描述

思路分析

汉诺塔问题求解的基本思路是，不断将n个盘的汉诺塔问题转换为2个n-1盘的汉诺塔问题,因此用递归实现是很自然的方法。当把n盘问题转换为n-1 盘问题时，问题的起始柱子和目标柱子也发生了变化。设n盘问题为(n，a，b，c），其中参数如实验内容中所定义,则问题的求解可转换为对(n-1,a,c,b)、（1,a,b,c）、（n-1,b,a,c)这三个问题的求解，其中(1,a.b,c)不需要递归，可直接实现。

在要求不用递归的情况下，可以借助自己建立的堆栈来解决问题。将待求解问题放入堆栈，然后不断将栈顶的问题分解，再将分解出的n>1 的新问题放入堆栈，如此不断循环一直到堆栈为空，问题求解就可结束。

注意：当将分解出的上述三个问题压入堆栈时，应该按照“需要先求解的问题后压入”的顺序,也就是压入顺序为（n-1,b,a,c）.（1,a,b,c）（n-1,a,c,b)。

伪代码

1
2
3
4
5
6
7
8
9
10
while（堆栈不空）
{
Pop 堆栈顶问题，设为(n',a', b', c');
if(n'为1）输出：a'->c ;
else{
Push ( (n'-1, b', a', c') ) ;
Push((1, a, b, c)) ;
Push( (n'-1, a', c', b')) ;
}
}

C++代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include<iostream>
#include<stack>
using namespace std;
struct Status
{
	int n;//盘数
	char a;//第一个柱子;
	char b;//第二个柱子;
	char c;//第三个柱子;
	Status(int n, char a, char b,char c) :n(n), a(a), b(b), c(c) {}
};
void dfs(Status sts) {
	stack<Status> stk;
	stk.push(sts);
	Status cur=sts;
	while (!stk.empty())
	{
		cur = stk.top();
		stk.pop();
		if (cur.n == 1) {
			cout << cur.a << "->" << cur.c << endl;
			continue;
		}
		stk.push(Status(cur.n -1, cur.b, cur.a, cur.c));
		stk.push(Status(1,cur.a,cur.b,cur.c));
		stk.push(Status(cur.n-1,cur.a,cur.c,cur.b));
		
	
	}
	return;
}
int main() {
	int n = 3;    //盘数
	char a = 'a';  //第一个柱子
	char b = 'b';  //第二个柱子
	char c = 'c';  //第三个柱子
	cout << "输入的盘子数为" << n << endl;
	cout << "移动顺序为" << endl;
	Status pro(n, a, b, c);
	dfs(pro);
}

结束语

如果有所收获，不妨一键三连，祝顺利！