Question

使用堆栈实现递归似乎是显而易见的。但是如何使用堆栈实现一般的递归呢？例如，如果我们有一个递归的自定义函数，我们可以只使用堆栈和迭代重写代码吗？

这是一个例子（我在另一篇文章中给出了错误的例子）：

def recursiveCall(node):
    if node==None:
        return (0,True)
    (left,lstatus) = recursiveCall(node.left)
    (right,rstatus) = recursiveCall(node.right)
    if lstatus==True and rstatus==True:
        if abs(left-right)<=1:
            return (max(left,right)+1,True)
        else:
            return (0,False)
    else:
        return (0,False)

或更容易：

def recursiveInorder(node):
    if node==None:
        return 
    recursiveInorder(node.left)
    print(node.val)
    recursiveInorder(node.right)

你如何使用堆栈实现这种递归？注意，我不是要求上面两个例子的迭代解决方案。我相信一定有。但我想这些迭代解决方案并没有尝试使用堆栈重现递归机制。我想要的是，如果可能的话，那些递归可以完全被自定义编码堆栈机制所取代（基本上使隐式递归机制嵌入在编译器中或者无论如何都是显式的）。

我认为需要找到一种方法来跟踪和恢复程序状态，局部变量等？ THX。

节点类定义为：

class node:
   def __init__(self,x):
      self.val=x
      self.left=None
      self.right=None

Answer 1

基本上，在模拟递归调用时，您需要推送堆栈局部变量以及返回后应该恢复执行的点。

我将通过编号注释在此处指出相关的执行点。将它们视为goto标签。

def recursiveInorder(node):
    #0
    if node==None:
        return 
    recursiveInorder(node.left)
    #1
    print(node.val)
    recursiveInorder(node.right)
    #2
    return

现在，我们可以使用if-elif语句来模拟goto语句：

def in_order(node):
    stack = [(None, None)] #sentinel
    goto = 0
    while stack:
        if goto == 0:
            if node is None:
                #return
                (node, goto) = stack.pop()
            else:
                #push state and recurse left
                stack.append((node, goto+1))
                (node, goto) = (node.left, 0)
        elif goto == 1:
            print(node.val)
            #push state and recurse right
            stack.append((node, goto+1))
            (node, goto) = (node.right, 0)
        else: 
            #return
            (node, goto) = stack.pop()

最后，会弹出(None, None)，但从不使用这些值，因为while循环结束。

<小时/> 上面的代码是直接转换的结果。接下来，我们可以应用各种优化来简化它。

最后一个else分支没有做有用的工作。我们可以删除它，如果我们也删除将带我们在那里的推动。

def in_order(node):
    stack = [(None, None)] #sentinel
    goto = 0
    while stack:
        if goto == 0:
            if node is None:
                #return
                (node, goto) = stack.pop()
            else:
                #push state and recurse left
                stack.append((node, goto+1))
                (node, goto) = (node.left, 0)
        else:
            print(node.val)
            #recurse right
            (node, goto) = (node.right, 0)

现在推送堆栈的goto值始终为1.我们只需要在堆栈上推送node并从堆栈弹出时指定goto = 1。

def in_order(node):
    stack = [None] #sentinel
    goto = 0
    while stack:
        if goto == 0:
            if node is None:
                #return
                (node, goto) = (stack.pop(), 1)
            else:
                #push state and recurse left
                stack.append(node)
                (node, goto) = (node.left, 0)
        else:
            print(node.val)
            #recurse right
            (node, goto) = (node.right, 0)

如果我们将内部if更改为while循环...

def in_order(node):
    stack = [None] #sentinel
    goto = 0
    while stack:
        if goto == 0:
            while node is not None:
                #push state and recurse left
                stack.append(node)
                node = node.left
            #return
            (node, goto) = (stack.pop(), 1)
        else:
            print(node.val)
            #recurse right
            (node, goto) = (node.right, 0)

...我们看到在if语句的每个分支之后，我们想要转到另一个分支，直到最后我们弹出sentinel值。如果我们在中间添加空堆栈检查，我们可以消除goto和if语句。如果我们在pop之前放置支票，我们就不再需要堆栈上的哨兵了。

def in_order(node):
    stack = []
    while True:
        while node is not None:
            stack.append(node)
            node = node.left
        if stack:
            node = stack.pop()
            print(node.val)
            node = node.right
        else:
            return

现在代码看起来简洁明了。

用堆栈替换任意递归？

1 个答案: