Python 如何在不改变变量的情况下递归

您好，我想知道是否有一种方法可以在不改变变量值的情况下通过函数递归

这是我的密码：

def helper_list_range(self, low, high, rangelist):
    if self is EmptyValue:
        return rangelist

    else:
        if self.left is not None and self.right is not None:
            if self.root <= high and self.root >= low:
                rangelist.append(self.root)

            self.left.helper_list_range(rangelist) 
            self.right.helper_list_range(rangelist) 

            return rangelist


def list_range(self, low, high):

    rangelist = []
    self.helper_list_range(low, high, rangelist)
    return rangelist

def helper_list_范围（自、低、高、范围列表）：
如果self为空值：
返回范围列表
其他：
如果self.left不是None，self.right不是None：
如果self.root=低：
rangelist.append（self.root）
self.left.helper\u列表\u范围（rangelist）
self.right.helper\u列表\u范围（rangelist）
返回范围列表
def列表_范围（自身、低、高）：
范围列表=[]
self.helper\u列表\u范围（低、高、范围列表）
返回范围列表

正如您所看到的，我使用的是一个helper函数，因此当函数执行递归时，我附加到范围列表，而不更改其值

---

我想知道有没有一种方法可以不使用helper函数来实现这一点。使用helper函数似乎有点晦涩。

我想您应该查找默认参数：

def list_range(self, low, high, rangelist = None):

    if rangelist is None:
        rangelist = []
    # here goes the code of helper_list_range

---

我认为您应该寻找默认参数：

def list_range(self, low, high, rangelist = None):

    if rangelist is None:
        rangelist = []
    # here goes the code of helper_list_range

---

我认为您应该寻找默认参数：

def list_range(self, low, high, rangelist = None):

    if rangelist is None:
        rangelist = []
    # here goes the code of helper_list_range

---

我认为您应该寻找默认参数：

def list_range(self, low, high, rangelist = None):

    if rangelist is None:
        rangelist = []
    # here goes the code of helper_list_range

---

如果我是你，我不会用self作为参数。最好传入树的根值，然后再进行处理。我也不会一直传入一个列表，然后在其中附加值。我认为通过堆叠的返回调用来建立列表值更有意义

根据你如何定义你的BST，我用一个函数为你的问题写了一个简短的解决方案。我还没有测试它，因为我没有你的数据结构，所以让我知道如果有任何错误

def list_range(node, low, high):
    # base case values for each side of the tree
    lowerHalf = []
    upperHalf = []
    # You have to check each node separately since one could be not None
    # You also have to check that the subtree can even satisfy your value
    if node.left != None and node.root >= low:
        lowerHalf = list_range(node.left, low, high)
    if node.right != None and node.root <= high:
        upperHalf = list_range(node.right, low, high)
    # if the root value is in the range then we just stick it in the middle of both return values
    if low <= node.root <= high:
        return  lowerHalf + node.root + upperHalf
    # otherwise we keep stepping down
    else:
        return lowerHalf + upperHalf

def list_范围（节点、低、高）：
#树每一侧的基本大小写值
lowerHalf=[]
上半部分=[]
#您必须单独检查每个节点，因为其中一个节点不能为“无”
#您还必须检查子树是否能够满足您的值
如果node.left！=无和node.root>=低：
lowerHalf=列表范围（node.left、low、high）
如果node.right！=None和node.root如果我是你，我不会使用self作为参数。最好传入树的根值，然后再进行处理。我也不会一直传入一个列表，然后在其中附加值。我认为通过堆叠的返回调用来建立列表值更有意义

根据你如何定义你的BST，我用一个函数为你的问题写了一个简短的解决方案。我还没有测试它，因为我没有你的数据结构，所以让我知道如果有任何错误

def list_range(node, low, high):
    # base case values for each side of the tree
    lowerHalf = []
    upperHalf = []
    # You have to check each node separately since one could be not None
    # You also have to check that the subtree can even satisfy your value
    if node.left != None and node.root >= low:
        lowerHalf = list_range(node.left, low, high)
    if node.right != None and node.root <= high:
        upperHalf = list_range(node.right, low, high)
    # if the root value is in the range then we just stick it in the middle of both return values
    if low <= node.root <= high:
        return  lowerHalf + node.root + upperHalf
    # otherwise we keep stepping down
    else:
        return lowerHalf + upperHalf

def list_范围（节点、低、高）：
#树每一侧的基本大小写值
lowerHalf=[]
上半部分=[]
#您必须单独检查每个节点，因为其中一个节点不能为“无”
#您还必须检查子树是否能够满足您的值
如果node.left！=无和node.root>=低：
lowerHalf=列表范围（node.left、low、high）
如果node.right！=None和node.root如果我是你，我不会使用self作为参数。最好传入树的根值，然后再进行处理。我也不会一直传入一个列表，然后在其中附加值。我认为通过堆叠的返回调用来建立列表值更有意义

根据你如何定义你的BST，我用一个函数为你的问题写了一个简短的解决方案。我还没有测试它，因为我没有你的数据结构，所以让我知道如果有任何错误

def list_range(node, low, high):
    # base case values for each side of the tree
    lowerHalf = []
    upperHalf = []
    # You have to check each node separately since one could be not None
    # You also have to check that the subtree can even satisfy your value
    if node.left != None and node.root >= low:
        lowerHalf = list_range(node.left, low, high)
    if node.right != None and node.root <= high:
        upperHalf = list_range(node.right, low, high)
    # if the root value is in the range then we just stick it in the middle of both return values
    if low <= node.root <= high:
        return  lowerHalf + node.root + upperHalf
    # otherwise we keep stepping down
    else:
        return lowerHalf + upperHalf

def list_范围（节点、低、高）：
#树每一侧的基本大小写值
lowerHalf=[]
上半部分=[]
#您必须单独检查每个节点，因为其中一个节点不能为“无”
#您还必须检查子树是否能够满足您的值
如果node.left！=无和node.root>=低：
lowerHalf=列表范围（node.left、low、high）
如果node.right！=None和node.root如果我是你，我不会使用self作为参数。最好传入树的根值，然后再进行处理。我也不会一直传入一个列表，然后在其中附加值。我认为通过堆叠的返回调用来建立列表值更有意义

根据你如何定义你的BST，我用一个函数为你的问题写了一个简短的解决方案。我还没有测试它，因为我没有你的数据结构，所以让我知道如果有任何错误

def list_range(node, low, high):
    # base case values for each side of the tree
    lowerHalf = []
    upperHalf = []
    # You have to check each node separately since one could be not None
    # You also have to check that the subtree can even satisfy your value
    if node.left != None and node.root >= low:
        lowerHalf = list_range(node.left, low, high)
    if node.right != None and node.root <= high:
        upperHalf = list_range(node.right, low, high)
    # if the root value is in the range then we just stick it in the middle of both return values
    if low <= node.root <= high:
        return  lowerHalf + node.root + upperHalf
    # otherwise we keep stepping down
    else:
        return lowerHalf + upperHalf

def list_范围（节点、低、高）：
#树每一侧的基本大小写值
lowerHalf=[]
上半部分=[]
#您必须单独检查每个节点，因为其中一个节点不能为“无”
#您还必须检查子树是否能够满足您的值
如果node.left！=无和node.root>=低：
lowerHalf=列表范围（node.left、low、high）
如果node.right！=None和node.root辅助函数与“附加到rangelist而不更改其值”无关。helper函数使用从主函数传入的空列表完成所有工作。是的，我在主函数中创建了空列表，但是如果我要在helper函数中创建它的话。列表将再次变为空。。一旦函数递归。所以我想知道，如果我们可以将列表放在递归所在的同一个函数中，那么helper函数与“附加到rangelist而不更改其值”没有任何关系。helper函数使用从主函数传入的空列表完成所有工作。是的，我在主函数中创建了空列表，但是如果我要在helper函数中创建它的话。列表将再次变为空。。一旦函数递归。所以我想知道，如果我们可以将列表放在递归所在的同一个函数中，那么helper函数与“附加到rangelist而不更改其值”没有任何关系。helper函数是使用empty完成所有工作的函数