Python3.6.3

递归和非递归两种方法，第三个函数是用来检验步骤正确与否的。 

from typing import List


def hanoi1(n: int, start: int = 0, target: int = 2) -> List[str]:
    """
    递归求解汉诺塔
    共有0,1,2三个柱子
    时间复杂度O(2^n)
    空间复杂度O(2^n)
        因为把整个操作步骤作为列表返回了，长度是2^n-1，所以空间复杂度是O(2^n)
        如果每一步直接打印出来而不是返回步骤列表，那么递归深度是n，空间复杂度是O(n)

    :param n: 汉诺塔层数
    :param start: 起始柱子
    :param target: 目标柱子
    :return: 字符串组成的列表，每个字符串代表一次操作，比如 '0->1' 代表0柱移动到1柱，按顺序操作即可完成移动
    """
    if n is 1:
        return ['%d->%d' % (start, target)]
    other = 3 - start - target
    return hanoi1(n - 1, start, other) + hanoi1(1, start, target) + hanoi1(n - 1, other, target)


def hanoi2(n: int) -> List[str]:
    """
    非递归求解汉诺塔
    时间复杂度O(2^n)
    空间复杂度O(2^n)
        步骤列表的长度是2^n-1
        如果不返回步骤列表，只是打印出来，那么用到了一个长度为n的列表（pillar里面），空间复杂度为O(n)

    非递归说明：
        准备：
            首先把三根柱子按顺序排成品字型，把所有的圆盘按从大到小的顺序放在柱子0上。
            根据圆盘的数量确定柱子的排放顺序
                                                 1
                > 若n为偶数，按顺时针方向依次摆放 0  2；

                                                 2
                > 若n为奇数，按顺时针方向依次摆放 0  1。
        1. 按顺时针方向把最小的圆盘从当前的柱子移动到下一根柱子
        2. 把另外两根柱子上可以移动的圆盘移动到新的柱子上。
            即把非空柱子上的圆盘移动到空柱子上；
            当两根柱子都非空时，移动较小的圆盘。
        3. 反复进行步骤1、2，最后就能按规定完成汉诺塔的移动。
    :param n: 汉诺塔层数
    :return: 字符串组成的列表，每个字符串代表一次操作，比如 '0->1' 代表0柱移动到1柱，按顺序操作即可完成移动
    """
    pillar = [list(range(n + 1, 0, -1)), [n + 1], [n + 1]]  # 三个柱子（均添加一个更大的盘，方便判断步骤2的移动方向）

    # 为步骤1准备好顺序
    # t = n % 2
    # p = (0, t + 1, 2 - t)
    if n % 2 == 1:
        p = (0, 2, 1)
    else:
        p = (0, 1, 2)

    steps = []  # 所有步骤
    j, k = 0, 1  # j,k供步骤1使用：步骤一从p[j]号柱子 移动到 p[k]号柱子
    while True:
        # 1
        steps.append('%d->%d' % (p[j], p[k]))  # 添加步骤
        pillar[p[k]].append(pillar[p[j]].pop())  # 移动
        j = k  # 更新j
        k += 1 if k != 2 else -2  # 更新k

        if len(pillar[-1]) == n + 1:  # 移动完成条件
            break

        # 2
        x, y = set(p) - {p[j]}  # 剩余两个柱子号
        if pillar[x][-1] < pillar[y][-1]:  # 小的向大的移动
            pillar[y].append(pillar[x].pop())  # 移动
            steps.append('%d->%d' % (x, y))  # 添加步骤
        else:
            pillar[x].append(pillar[y].pop())
            steps.append('%d->%d' % (y, x))
    return steps


def move(pillar_0: List[int], pillar_1: List[int], pillar_2: List[int], steps: List[str]):
    """检验函数：按照steps里指定的步骤移动汉诺塔"""
    d = {'0': pillar_0, '1': pillar_1, '2': pillar_2}
    for step in steps:
        d[step[-1]].append(d[step[0]].pop())


def main():
    n = 20
    a = list(range(n, 0, -1))
    b = []
    c = []

    # res1 = hanoi1(n)
    res2 = hanoi2(n)
    # print(res1 == res2)
    
    print(a, b, c)
    move(a, b, c, res2)
    print(a, b, c)


if __name__ == '__main__':
    main()