递归和迭代，以及汉诺塔，采用迭代法不容易实现的说明

Posted 2020-12-10 nocomment

这里拿一直被作为递归来举例而强行递归（无需递归就可求出的）的阶乘来说明

N！=N*(N-1)！

递归：就是要解决x(N)问题，转化成x(N-1)问题

他的展开：N！=N*(N-1)*(N-2)*...*3*2*1

迭代：N！=(N-1)！*N

他的展开：N=1*2*3...*(N-2)*(N-1)*N

个人的说明能力很有限，就是他们执行时，步骤是不同的，解决问题的结构是不同的。

递归在执行N！=N*(N-1)！时，实际(N-1)！是个什么值，是不知道的

迭代：N！=(N-1)！*N，时，(N-1)！的值已经是得出结果的

这个根节点可以看作是1！，因为从7到1，以及从1到7都是单行道，没分支。所以说这是一个最简单的例子。

汉诺塔是介绍递归最好的例子，因为移动N个盘子，可以转化成移动(N-1)个盘子的问题，最后归结到移动一个盘子的问题（这个是没有难度的）。通过递归，顺便找到了每一步演化的路线。

而迭代，就是不光不能用递归，而且不能用push，pop，因为这就是你手动实现了递归。而是要从根节点开始，一步一步迭代，推导到最后完成那一步。如果绕了一圈，我终于知道该怎么迭代，这个也是不行的，属于强行迭代。因为从问题开始节点，你不知道该怎么迭代。所以说这个用迭代是不明智的。

这里拿求出一个二叉树的第三层所有节点的递归，迭代python程序（虽然拿这个做例子会越说越糊涂）：

class My_tree:
    my_root = None
    def __init__(self,id):
        self.id=id
        self.left = None
        self.right = None
    def create_left(self):
        left = My_tree(self.id + ‘l‘)
        self.left = left
        return left
    def create_right(self):
        right = My_tree(self.id + ‘r‘)
        self.right = right
        return right
    @staticmethod
    def sub_nodes(nodes):
        s_nodes = []
        for node in nodes:
            if node.left != None:
                s_nodes.append(node.left)
            if node.right != None:
                s_nodes.append(node.right)
        return s_nodes

tr = My_tree(‘root_‘)
My_tree.my_root = tr
tr_l=tr.create_left()
tr_r=tr.create_right()
tr_l_l=tr_l.create_left()
tr_l_r=tr_l.create_right()
tr_r_l=tr_r.create_left()
tr_r_r=tr_r.create_right()

def recursive(n):
    return recursive3(n-1)

def recursive3(n):
    if n==0:
        nodes = [My_tree.my_root]
    else:
        nodes = recursive3(n-1)
    nodes = My_tree.sub_nodes(nodes)
    return nodes

print("递归求解############")
nodes = recursive(2)
print(nodes)

print("迭代求解############")
k=0
nodes=[My_tree.my_root]
while k<2:
    nodes = My_tree.sub_nodes(nodes)
    k += 1
print(nodes)