如何使用另一个空链表递归地反转单链表？

Question

Node and Linked List classes:

class Node:
    def __init__(self, elm, nxt):
        self.elm = elm
        self.nxt = nxt
    
class LnLs:
    def __init__(self, s = None):
        self.head = None
        if s:
            for x in s:
                self.push(x)
            self.reverse()
            
    def __bool__(self):
        return self.head is not None

    def top(self):
        if not self:
            raise IndexError
        return self.head.elm

    def push(self, x):
        self.head = Node(x, self.head)

    def pop(self):
        x = self.top()
        self.head = self.head.nxt 
        return x

    def __iter__(self):
        p = self.head
        while p:
            yield p.elm
            p = p.nxt

    def index_of(self, x):
        for i, y in enumerate(self):
            if x == y:
                return i
        return -1

    def __getitem__(self, i):
        for j, x in enumerate(self):
            if i == j:
                return x
        raise IndexError

    def reverse(self):
        q, p = None, self.head
        # q points to the previous node
        while p:
            t = p.nxt
            p.nxt = q
            q = p
            p = t
        self.head = q
        
    def reverse(h, q):
        if h.head is None:
            return q
        else:
            t = h.head.nxt
            h.head.nxt = q
            return reverse(t, h)

no matter what I do I just can't get it to work I've tried adding another reverse(h,q) in the Node class. I've been trying this for at least 5 hours now and any help will be much appreciated, This is actually for my assignment, I have the answer for the exact same question from last year, which is

def reverse(h, q):
    if h is None:
        return q
    else:
        t = h.nxt
        h.nxt = q
    return reverse(t, h)

EDIT1:Sorry for the poor question asking technique. This is my first time asking question here. I am trying to use this function to reverse a linked list h using another empty linked list qeg my linked list is: 1->2->3. if I input:"ll.reverse(LnLs())",then I expect my linked will be changed to 3->2->1. at first I run this code it says "AttributeError: 'LnLs' object has no attribute 'nxt'". Then I change the code to:

def reverse(h, q):
        if h.head is None:
            return q
        else:
            t = h.head.nxt
            h.head.nxt = q
            return reverse(t, h)

now it says NameError: name 'reverse' is not defined. if I add this function in the form of another kind of indentation(Sorry, I don't know what this is called in Python, I will use a picture as an example):

Then I run the testing codes and now my linked only has one element:

if __name__ == '__main__':
    ll = LnLs()
    ll.push('apple')
    ll.push('orange')
    ll.push('peach')
    for x in ll:
        print(x)
    ll.reverse(LnLs())
    for x in ll:
        print(x)

output: peach orange apple peach

This is the point where I get confused as I don't know what else can I do. Thanks again.

Answer 1

Here are some of the issues:

• In your first code block you defined reverse twice in the class, and by consequence the second definition overwrites the first.

• The second reverse method makes a call to reverse . There is no global reverse function, only a method with that name.

• If you change the "signature" of reverse to take an extra linked list argument, you need to also change the call to reverse that the constructor makes, because that call is currently not passing a second argument. Or, alternatively, you should think of another name for this second reverse method.

• Even if you correct the reverse recursive call to be called like a method, you don't have a linked list to call it on. t is a node, not a linked list, so if you would write t.reverse(h) , it would lead to an error, as a Node instance does not have a reverse method. In fact, at the moment you want to make the reverse recursive call, you don't have the two linked lists that are required to make the call.

So, I would suggest to call the new method differently, copy_reverse :

    def copy_reverse(self, other=None):
        if other is None:   # in case the argument was not provided
            # ...make a copy of the list so the original will not be destroyed,
            # ...and pass an empty linked list as argument 
            return LnLs(iter(self)).copy_reverse(LnLs())
        if not self:
            return other
        other.push(self.pop())
        return self.copy_reverse(other)

Explanation

The idea of this function is to pop each element from the first list and push it to the second. At the end the first list will be empty, and the second list will have the reversed list.

Note that this is destructive to the first list, so it might be nice to have this happen to a copy of the list. That way the caller will not be unpleasantly surprised with an emptied list.

So we first check whether the second argument as given (it defaults to None ). If not, then we make a copy of the current linked list (using iter , which calls the __iter__ method), and call the function again, but this time on the copy, and providing the second argument.

Then we extract the first element from the list and push it (at the front of) the second list. This is repeated via recursive calls until the first list is empty. The result is returned.

This also means that the caller needs to capture the return value of the call to copy_reverse . So your main code would look as follows:

ll = LnLs()
ll.push('apple')
ll.push('orange')
ll.push('peach')
for x in ll:
    print(x)
result = ll.copy_reverse()  # <-- changed
for x in ll:
    print(x)

Or, shorter:

ll = LnLs(['apple', 'orange', 'peach'])
print(list(ll))
result = ll.copy_reverse()
print(list(result))