反向链接列表，同时保留原始顺序

Question

我想将一个链接的列表head反转为一个新的反向喜欢的列表。 我可以反转列表，但是这样做会影响原始列表的head并且head.next变为None 。

def reverse(head): 
    prev = None
    current = head 
    while(current is not None): 
        next = current.next
        current.next = prev 
        prev = current 
        current = next 

最初：head： 1-->2-->3-->4-->None

反转后：头： 1-->None一条： 4-->3-->2-->1-->None

我基本上希望head为1-->2-->3-->4-->None 。

这是链表反转的代码：-

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

def print_llist(head):
    while (head):
        print(head.data)
        head = head.next

def reverse(head):
    prev = None
    current = head
    while (current is not None):
        next = current.next
        current.next = prev
        prev = current
        current = next
    return prev


llist = Node(1)
second = Node(2)
third = Node(3)
fourth = Node(4)

llist.next = second
second.next = third
third.next = fourth

# print original list
print("Original:")
print_llist(llist)

# print reversed list
print("Reversed")
print_llist(reverse(llist))

# print original list
print("Original:")
print_llist(llist)

输出：-

Original:
1
2
3
4
Reversed
4
3
2
1
Original:
1

预期产量：-

Original:
1
2
3
4
Reversed
4
3
2
1
Original:
1
2
3
4

Answer 1

在while循环结束后添加current.next=prev 。 并将您的while循环条件更改为while(current.next is not None):

从您的函数而不是prev返回current 。 另外，添加条件以查看head是否为None 。

所以您的功能如下

def reverse(head):
     if head is None:
         return head
     prev=None
     current=head
     while(current.next is not None):
             next=current.next
             current.next=prev
             prev=current
             current=next
     current.next = prev
     return current

Answer 2

首先编写Node ，以便您可以传递data 然后编写next构造函数-

class Node:
  def __init__(self, data, next = None):
    self.data = data
    self.next = next

这使我们可以写-

mylist = Node(1, Node(2, Node(3, Node(4))))

您还将看到我们如何reverse使用Node的第二个参数-

def reverse(llist):
  def loop (r, node):
    if node is None:
      return r
    else:
      return loop (Node(node.data, r), node.next)
  return loop (None, llist)

注意，我们如何构造一个新的Node而不是使用node.data = ...或node.next = ...修改node 。 递归可以优雅地表达解决方案，而无需更改原始输入。

我们也可以使用递归将链接列表转换为字符串-

def to_str(node):
  if node is None:
    return "None"
  else:
    return f"{node.data} -> {to_str(node.next)}"

print(to_str(mylist))
# 1 -> 2 -> 3 -> 4 -> None

让我们确认reverse不会改变原始链表-

mylist = Node(1, Node(2, Node(3, Node(4))))

revlist = reverse(mylist)

print(to_str(mylist))
# 1 -> 2 -> 3 -> 4 -> None

print(to_str(revlist))
# 4 -> 3 -> 2 -> 1 -> None

print(to_str(mylist))
# 1 -> 2 -> 3 -> 4 -> None

---

与您的问题并不完全相关，但是您可以考虑直接在Node上实现__str__更为“ __str__ ”，以便可以使用print输出链接列表-

class Node:
  def __init__(self, data, next = None):
    self.data = data
    self.next = next

  def __str__(self):
    return f"{self.data} -> {self.next}"

现在，不希望用户手动使用to_str或print_llist

mylist = Node(1, Node(2, Node(3, Node(4))))

print(mylist)
# 1 -> 2 -> 3 -> 4 -> None

print(reverse(mylist))
# 4 -> 3 -> 2 -> 1 -> None