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

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

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)

; "复制代码")