Question

我创建了一个递归反转列表的函数，但它使用全局列表来放置元素。可以重写它，以便它不会使用外部变量/列表来实现相同的结果。

以下是代码：

invs = []

def inv_list(list_, elem):
    global invs

    if elem is not None:
        invs.append(elem) 

    if not list_:
        return invs

    else:
        try:
            el = list_.pop()
            inv_list(list_, el)

        except Exception:
            pass

Answer 1

怎么样：

def inv_list(lst):
    if not lst:
        return []
    return inv_list(lst[1:]) + lst[:1]

Answer 2

看起来你做的工作比你需要的要多得多

def reverse_recurse(a_list):
    if not a_list:
        return []
    return [a_list.pop(),] + reverse_recurse(a_list)

Answer 3

虽然你的实现可以通过各种方式得到改进，但是当我发现我想在不使用全局变量的情况下构建递归的东西并且不使接口感觉脏的时候创建一个嵌套的辅助函数：

def inv_list(list_):
    invs = []

    def helper(elem):
        if elem is not None:
            invs.append(elem) 

        if not list_:
            return invs
        else:
            try:
                el = list_.pop()
                return helper(el)
            except Exception:
                pass

    return helper(None)

这样，您可以拥有外部函数范围内的值。

Answer 4

有问题的方法是简单，只需使用默认参数。

def rec_reverse(input=[], output=[]):
    if len(input) == 0:
        return
    else:
        output.append(input.pop())
        rec_reverse(input, output)
        return output

x = list(range(10))
y = list(range(20))
print(rec_reverse(x, []))
print(rec_reverse(y, []))

只需记住即可将新列表传递给输出，以便您可以再次调用它而无需获取旧值。

然而，您可以使用安全方法而不使用默认参数：

def rec_reverse(input):
    if not input:
        return input
    else:
        return [input.pop(), ] + rec_reverse(input)

您还可以将其递归等效项用作lambda表达式：

rec_reverse = lambda input=[]: [] if not input else [input.pop(), ] + rec_reverse(input)

请记住，在没有使用递归的情况下，这是一个更简单的解决方案：

x = list(range(10))
rec_reverse = lambda input: input[::-1]
print(rec_reverse(x))

因为在Python中，您可以使用extended slice notation来反转任何列表。

另外，你可以使用reverse（）并省去麻烦。

def reverse(input):
    input.reverse()
    return input

Answer 5

以Rederick Deathwill为基础，这是您的功能的简化版本：

def inv_list(list_):
    def inner(list_, invs):
        if not list_:
            return invs
        else:
            invs.append(list_.pop())
            return inner(list_, invs)

    return inner(list_, [])

它使用invs的默认值，摆脱了保存倒排列表的全局变量的需要。随后的调用，传递invs，以便下一个调用可以在它上构建。

一旦达到调用堆栈的底部，该函数将返回反转列表。原始的一个很好的补充是return inner(list_, invs)行，它允许调用者捕获新列表作为返回值。

这不是最短的，但我认为它至少是可读的。

以递归方式反转列表

5 个答案: