Hanoi塔问题的递归算法与非递归算法

1. 递归算法：
n=1时，很简单只需要将编号为1的圆盘从A移动到B即可。
n>1时，只需要利用辅助塔C，先将n-1个较小的圆盘移动到C塔，再将剩下最大的圆盘移动到B塔，最后再将n-1个圆盘从C塔移动到B塔就可以了。

• 代码实现：

def move(a,b):
    b.append(a.pop(-1))
    return b
def Hanoi(n,a,b,c):
    if n>0:
        Hanoi(n-1, a, c, b)
        b=move(a,b)
        Hanoi(n-1, c, b, a)
def Hanoire(n,a,b,c): 
    a=list(range(1,n+1))
    Hanoi(n,a,b,c) 
a=list()
b=list()
c=list()
Hanoire(10, a, b, c)

• 时间复杂度：

当规模为n时时间函数为T(n)，在代码中，两次调用规模为（n-1）的汉诺塔函数，还有一次输出语句，运算时间为常数n，所以时间函数为T(n)=2*T(n-1)+1，得T(n)=2n-1，时间复杂度为O(2**n)。

2.非递归算法：

假设A,B,C，排成一个三角形，A->B->C->A构成一个顺时针循环。若是奇数次移动，将最小的圆盘顺时针移动到下一座塔上。若是偶数次移动，最小的圆盘不动，在其他两座塔上将更小的圆盘移动到下一坐塔上。

• 代码实现：

def minre(a):
    if len(a)==0:
        return 1000
    else:
        return min(a)
def Hanoi(n,a,b,c):
    a=list(range(n,0,-1))
    lena=len(a)
    i=1
    while len(b)!=lena:
        
        if(i%2!=0):
            if minre(a)==1:
                a.remove(1)
                b.append(1)
                if(len(b)==lena):
                    break
            elif minre(b)==1:
                b.remove(1)
                c.append(1)
            elif min(c)==1:
                c.remove(1)
                a.append(1)
        else:
            if minre(a)==1:
                if minre(b)<minre(c):
                    c.append(b.pop(-1))
                else:
                    b.append(c.pop(-1))
            elif minre(b)==1:
                if minre(a)<minre(c):
                    c.append(a.pop(-1))
                else:
                    a.append(c.pop(-1))
            elif min(c)==1:
                if minre(b)<minre(a):
                    a.append(b.pop(-1))
                else:
                    try:
                        b.append(a.pop(-1))
                    except:
                        print("finish")
        i=i+1        
a=list()
b=list()
c=list()
Hanoi(10, a, b, c)  

• 时间复杂度：

其实仔细分析会发现非递归算法和递归算法，在实际操作上其实步骤是一样的。分析可得时间复杂度为O(2**n)。

3. 总结：

仔细分析会发现非递归算法和递归算法，在实际操作上其实步骤是一样的。时间复杂度都为O(2**n)，所以递归算法和非递归算法实际上是一回事。