1. 经典递归解法

#include <iostream>

void mov(char a, char b)
{
	std::cout << a << " -> " << b << std::endl;
}

void recursive_hanoi(int n, char a, char b, char c)
{
	if (n == 0) return;
	recursive_hanoi(n - 1, a, c, b);
	mov(a, c);
	recursive_hanoi(n - 1, b, a, c);
}

int main() 
{
	recursive_hanoi(3, '1', '2', '3');
	return 0;
}

2. 非递归解法

从汉诺塔的递归解法可以看出，它跟二叉树中序遍历递归解法是一个道理。既然二叉树非递归解法能写出来，那么汉诺塔非递归解法也不难写出来。

#include <iostream>
#include <stack>

struct HanoiNode
{
private:
	int num = 0;
	char a, b, c;

public:
	HanoiNode() = default;
	HanoiNode(int n_, char a_, char b_, char c_)
		: num(n_), a(a_), b(b_), c(c_) {}

	bool is_null()
	{
		return num == 0;
	}

	HanoiNode left()
	{
		if (is_null()) return *this;
		return HanoiNode(num - 1, a, c, b);
	}

	HanoiNode right()
	{
		if (is_null()) return *this;
		return HanoiNode(num - 1, b, a, c);
	}

	void mov() const { std::cout << a << " -> " << c << std::endl; }
};

void nonrecursive_hanoi(int n, char a, char b, char c)
{
	if (n < 0) return;

	std::stack<HanoiNode> hn;
	HanoiNode hnd(n, a, b, c);

	while (!hnd.is_null() || !hn.empty())
	{
		if (!hnd.is_null())
		{
			hn.push(hnd);
			hnd = hnd.left();
		}
		else
		{
			hnd = hn.top();
			hn.pop();
			
			hnd.mov();
			hnd = hnd.right();
		}
	}
}

int main() 
{
	nonrecursive_hanoi(3, '1', '2', '3');
	return 0;
}