Wie kann ich das umkehren einer Liste mit Rekursion in Python?

Möchte ich eine Funktion haben, die Rückkehr der Rückseite eine Liste, die es gegeben-mit Rekursion. Wie kann ich das tun?

  • Wie ist das nicht Hausaufgaben?
InformationsquelleAutor |
  1. 10

    Anfügen, das erste element der Liste, um eine umgekehrte Teilliste:

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

    Etwas expliziter:

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

    Dieser verwandelt sich in:

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

    Welches sich in:

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

    Das ist das gleiche wie eine andere Antwort.

    Tail recursive /CPS-Stil (der python nicht optimieren für eh):

    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]
    InformationsquelleAutor Claudiu
  3. 6

    Ich weiß, es ist nicht eine hilfreiche Antwort (obwohl diese Frage wurde schon beantwortet), aber im eigentlichen code, bitte tun Sie das nicht. Python kann nicht optimieren tail-fordert, hat langsame Funktionsaufrufe und hat eine Feste Rekursionstiefe, also es gibt mindestens 3 Gründe, warum es zu tun iterativ statt.

    • Nicht zu Stimme mit Ihnen auf die Substanz "bitte tun Sie das nicht im echten code". In diesem speziellen Fall, spielt es keine Rolle, dass Python nicht optimiert Schwanz Anrufe, weil Liste reversion ist nicht tail-rekursiv, ohne CPS.
    InformationsquelleAutor
  4. 3

    Der trick ist, sich nach recursing:

    def rückwärts(l): 
wenn nicht l: 
zurück 
x, y = l[0], l[1:] 
zurück in die Vergangenheit(y) + [x]
    InformationsquelleAutor Ignacio Vazquez-Abrams
  5. 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]
    InformationsquelleAutor
  6. 2

    Verwenden Sie die Divide & conquer-Strategie. D&C-algorithmen, rekursive algorithmen.
    Um dieses problem zu lösen Sie mithilfe der D&C, gibt es zwei Schritte:

    1. Herauszufinden, die base-case. Dies sollte der einfachste mögliche Fall.
    2. Teilen oder verringern Sie Ihr problem, bis es dann in die Basis Fall.

    Schritt 1: herausfinden der base case. Was ist die einfachste Liste könnte man
    bekommen? Wenn Sie eine Liste mit 0 oder 1 element, das ist ziemlich einfach zu summieren.

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

    Schritt 2: Sie brauchen, um eine Annäherung an eine leere Liste mit jedem rekursiven
    rufen Sie

    recursive(l)    #recursion case

    beispielsweise

    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]

    Quelle : Grokking Algorithmen

    InformationsquelleAutor
  7. 1

    Dieser eine kehrt im Ort. (Natürlich eine iterative version wäre besser, aber es muss rekursiv sein, hat es nicht?)

    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
    InformationsquelleAutor Federico A. Ramponi
  8. 1
    def reverse(q):
    if len(q) != 0:
        temp = q.pop(0)
        reverse(q)
        q.append(temp)
    return q
    InformationsquelleAutor
  9. 1

    sieht einfacher:

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

    Nehmen Sie das erste element, kehren Sie den rest der Liste rekursiv, und fügen Sie das erste element am Ende der Liste.

    InformationsquelleAutor JesperE
  11. 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

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

    InformationsquelleAutor
  12. 0

    Verwendung von Änderbaren Standard-argument und die Rekursion :

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

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

hello("word")

    zusätzliche info

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

    Rekursion Teil ist hello(x[:-1]) wo seine Berufung hello-Funktion erneut nach x[:-1]

    InformationsquelleAutor
  13. 0

    Warum nicht:

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

    Dieser umkehren wird, eine verschachtelte Listen auch!

    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

    InformationsquelleAutor
Schreibe einen Kommentar