如何在Python中使用递归来反转列表?

时间:2008-10-19 06:56:02

标签: python list recursion

我想要一个函数,它将返回给出的列表的反向 - 使用递归。我怎么能这样做?

21 个答案:

答案 0 :(得分:10)

将列表的第一个元素附加到反向子列表:

mylist = [1, 2, 3, 4, 5]
backwards = lambda l: (backwards (l[1:]) + l[:1] if l else []) 
print backwards (mylist)

答案 1 :(得分:7)

更明确一点:

def rev(l):
    if len(l) == 0: return []
    return [l[-1]] + rev(l[:-1])

这变成了:

def rev(l):
    if not l: return []
    return [l[-1]] + rev(l[:-1])

变成了:

def rev(l):
    return [l[-1]] + rev(l[:-1]) if l else []

与另一个答案相同。


尾递归/ CPS样式(无论如何python都没有优化):

def rev(l, k):
    if len(l) == 0: return k([])
    def b(res):
        return k([l[-1]] + res)
    return rev(l[:-1],b)


>>> rev([1, 2, 3, 4, 5], lambda x: x)
[5, 4, 3, 2, 1]

答案 2 :(得分:6)

我知道这不是一个有用的答案(虽然这个问题已经得到解答),但在任何实际代码中,请不要这样做。 Python无法优化尾调用,函数调用速度慢并且具有固定的递归深度,因此至少有3个理由反而以迭代方式执行。

答案 3 :(得分:3)

诀窍是在递归之后加入

def backwards(l):
  if not l:
    return
  x, y = l[0], l[1:]
  return backwards(y) + [x]

答案 4 :(得分:2)

def revList(alist):
    if len(alist) == 1:       
        return alist #base case
    else:
        return revList(alist[1:]) + [alist[0]]

print revList([1,2,3,4])
#prints [4,3,2,1]

答案 5 :(得分:2)

使用Divide&征服战略。 D& C算法是递归算法。 要使用D& C解决这个问题,有两个步骤:

  1. 弄清楚基本情况。这应该是最简单的情况。
  2. 将问题分开或减少,直至成为基本案例。
  3. 步骤1:找出基本情况。什么是最简单的清单 得到?如果你得到一个包含0或1个元素的列表,那很容易总结。

    if len(l) == 0:  #base case
        return []
    

    步骤2:每次递归都需要靠近空列表 调用

    recursive(l)    #recursion case
    

    例如

    l = [1,2,4,6]
    def recursive(l):
        if len(l) == 0:
            return []  # base case
        else:
            return [l.pop()] + recursive(l)  # recusrive case
    
    
    print recursive(l)
    
    >[6,4,2,1]
    

    来源:Grokking算法

答案 6 :(得分:1)

这个反转到位。 (当然迭代版本会更好,但它必须是递归的,不是吗?)

def reverse(l, first=0, last=-1):
    if first >= len(l)/2: return
    l[first], l[last] = l[last], l[first]
    reverse(l, first+1, last-1)

mylist = [1,2,3,4,5]
print mylist
reverse(mylist)
print mylist

答案 7 :(得分:1)

def reverse(q):
    if len(q) != 0:
        temp = q.pop(0)
        reverse(q)
        q.append(temp)
    return q

答案 8 :(得分:1)

用于递归列表的递归函数。

def reverseList(lst):
    #your code here
    if not lst:
        return []
    return [lst[-1]] + reverseList(lst[:-1])


print(reverseList([1, 2, 3, 4, 5]))

答案 9 :(得分:1)

看起来更简单:

    def reverse (n):
        if not n: return []
        return [n.pop()]+reverse(n)

答案 10 :(得分:0)

您正在寻找的答案在函数内部。剩下的就是看看(或者如果你想比较)不同算法所花费的时间。

import time
import sys

sys.setrecursionlimit(10**6)


def reverse(ls1):
    if len(ls1) <= 1:
        return ls1
    else:
        ls1[0], ls1[-1] = ls1[-1], ls1[0]
        return [ls1[0]] + reverse(ls1[1:-1]) + [ls1[-1]]


ls = [*range(2000)]
start_time = time.time()
print(reverse(ls))
stop_time = time.time()
print(f"Total time taken: {(stop_time - start_time) * 1000} msec.")

答案 11 :(得分:0)

取第一个元素,递归地反转列表的其余部分,并将第一个元素追加到列表的末尾。

答案 12 :(得分:0)

您可以通过一次交换第一个和最后一个元素并在列表中间递归调用 rev 来将递归深度减少一半:

lks=[2,7,3,1,9,6,5]
def rev(lks):
    if len(lks)<2:
        return lks
    return [lks[-1]]+rev(lks[1:-1])+[lks[0]]
print(rev(lks))

答案 13 :(得分:0)

如果它是数字的最简单的逆转方法,它将是。这也适用于字符串,但不建议使用。

l1=[1,2,3,4]
l1 = np.array(l1)
assert l1[::-1]==[4,3,2,1]

如果您不想将其保留为numpy数组,则可以将其作为列表传递给

l1 = [*l1]

再次,我不建议将它用于字符串列表,但如果您确实愿意,可以这样做。

答案 14 :(得分:0)

这也将反转嵌套列表!

A = [1, 2, [31, 32], 4, [51, [521, [12, 25, [4, 78, 45], 456, [444, 111]],522], 53], 6]

def reverseList(L):

    # Empty list
    if len(L) == 0:
        return

    # List with one element
    if len(L) == 1:

        # Check if that's a list
        if isinstance(L[0], list):
            return [reverseList(L[0])]
        else:
            return L

    # List has more elements
    else:
        # Get the reversed version of first list as well as the first element
        return reverseList(L[1:]) + reverseList(L[:1])

print A
print reverseList(A)

Padmal's BLOG

答案 15 :(得分:0)

为什么不:

a = [1,2,3,4,5]
a = [a[i] for i in xrange(len(a)-1, -1, -1)] # now a is reversed!

答案 16 :(得分:0)

使用Mutable默认参数和递归:

def hello(x,d=[]):
    d.append(x[-1])
    if len(x)<=1:
        s="".join(d)
        print(s)

    else:
        return hello(x[:-1])

hello("word")

其他信息

x[-1]    # last item in the array
x[-2:]   # last two items in the array
x[:-2]   # everything except the last two items

递归部分是hello(x[:-1]),在x[:-1]之后再次调用hello函数

答案 17 :(得分:0)

def reverseList(listName,newList = None):
if newList == None:
    newList = []
if len(listName)>0:
    newList.append((listName.pop()))
    return reverseList(listName, newList)
else:
    return newList

print reverseList([1,2,3,4]) [4,3,2,1]

答案 18 :(得分:-1)

def reverse_array(arr, index):
if index == len(arr):
    return

if type(arr[index]) == type([]):
    reverse_array(arr[index], 0)

current = arr[index]
reverse_array(arr, index + 1)
arr[len(arr) - 1 - index] = current
return arr

如果名称 =='主要”: print(reverse_array([[4,5,6,[4,4,[5,6,7],8],8,7],0))

答案 19 :(得分:-1)

def reverse_array(arr, index):
    if index == len(arr):
        return

    if type(arr[index]) == type([]):
        reverse_array(arr[index], 0)

    current = arr[index]
    reverse_array(arr, index + 1)
    arr[len(arr) - 1 - index] = current
    return arr

if __name__ == '__main__':
    print(reverse_array([[4, 5, 6, [4, 4, [5, 6, 7], 8], 8, 7]], 0))

答案 20 :(得分:-1)

def disp_array_reverse(inp, idx=0):
    if idx >= len(inp):
        return
    disp_array_reverse(inp, idx+1)
    print(inp[idx])