lavos/cap3/ex5.go

package cap3

import "lavos/common"

// Ex5 例题5 汉诺塔问题，输出移动的步骤，可指定算法类型，每做出一步移动操作都将会调用callback
func Ex5(beadNum int, algoType AlgoType, callback func(from string, to string)) {
	switch algoType {
	case AlgoTypeRecursion:
		Ex5Recursive(beadNum, "A", "B", "C", callback)
	default:
		Ex5NonRecursive(beadNum, "A", "B", "C", callback)
	}
}

func Ex5Recursive(beadNum int, a, b, c string, callback func(from string, to string)) {
	if beadNum == 1 {
		// 如果只有一颗珠子，直接从 A 移动到 C，结束
		callback(a, c)
	} else {
		// 第二步：将所有在 N 之上的珠子（即 N-1 颗珠子）从 A 移动到 B。此时 C 是中转站
		Ex5Recursive(beadNum-1, a, c, b, callback)

		// 第二步：将 A 的珠子移动到 C
		callback(a, c)

		// 第三步：将剩余的 N-1 颗珠子从 B 移动到 C。此时 A 是中转站
		Ex5Recursive(beadNum-1, b, a, c, callback)
	}
}

type _step struct {
	n                 int
	from, transit, to string
}

func Ex5NonRecursive(beadNum int, a, b, c string, callback func(from string, to string)) {
	stack := common.NewStack[_step](beadNum * 5)
	// 最终状态：a->c，b作为中转
	stack.Push(&_step{
		n:    beadNum,
		from: a, transit: b, to: c,
	})
	for !stack.Empty() {
		status := stack.Pop()
		if status.n == 1 {
			callback(status.from, status.to)
		} else {
			// 把子问题的三个基本步骤压入栈
			stack.Push(&_step{
				n:       status.n - 1,
				from:    status.transit,
				transit: status.from,
				to:      status.to,
			})
			stack.Push(&_step{
				n:       1,
				from:    status.from,
				transit: status.transit,
				to:      status.to,
			})
			stack.Push(&_step{
				n:       status.n - 1,
				from:    status.from,
				transit: status.to,
				to:      status.transit,
			})
		}
	}
}