使用递归逆转单链表

Question

我做了一个使用递归方法来反转单链表的函数。 但是我在执行下面的代码时遇到了一些困难：

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

class linked_list:
    def __init__(self):
        self.head=node()

def append(self,data):
    new_node=node(data)
    cur_node=self.head
    while (cur_node.next!=None):
        cur_node=cur_node.next
    cur_node.next=new_node
    return cur_node.data

def display(self):
    elements=[]
    cur_node=self.head
    while(cur_node.next!=None):
        cur_node=cur_node.next
        elements.append(cur_node.data)
    print(elements)

def reverseRecursive(self,prev_code,cur_node):
    if cur_node.next!=None:
        reverseRecursive(cur_node,cur_node.next)
        cur_node.next=prev_node
    else:
        self.head=cur_node
    return
lst1=linked_list()
lst1.display()
lst1.append(1)
lst1.append(3)
lst1.append(5)
lst1.append(7)
lst1.display()
lst1.reverseRecursive(None,_____)
lst1.display()

我应该在reverseRecursive函数/方法中传递第二个参数，以便执行该参数吗？

作为第二个参数，我只想传递链接列表的头节点。 但我不知道如何从类linked_list的init方法获得头节点

我已经尝试了几种方法，但是无法解决。 也许我不太擅长OOP概念。 谁能帮我解决这个问题？

Answer 1

链表是一个递归结构，因此将其与功能样式一起使用将产生最佳效果。 在您的程序中，您已使用过程样式和可变节点实现了一个链表-您随时间更改data值和next值。 尽管这听起来像是一种直观的方法，但我想专注于一门不变的学科，使我们摆脱了严重的国家复杂性。

首先，我们修复node构造函数。 我们在构造新节点时会同时设置这两个属性，因为它们在程序后面不会更改–

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

然后， linked_list只是由特定约定构造的单个节点：

• node.data持有节点的数据
• node.next是：
  • 另一个linked_list
  • 或 （ None ）代表列表的末尾

我们从linked_list的构造函数开始–

class linked_list:
  def __init__ (self, node = None):
    self.node = node

  # ...

并实现is_empty ， head和tail 属性来抽象出node –

class linked_list:
  def __init__ (self, node = None):
    self.node = node

  @property
  def is_empty (self):
    return self.node is None

  @property
  def head (self):
    if self.is_empty:
      raise Exception ("cannot get head of an empty list")
    else:
      return self.node.data

  @property
  def tail (self):
    if self.is_empty:
      raise Exception ("cannot get tail of an empty list")
    else:
      return self.node.next

现在， node的使用已完全抽象化，我们可以使用新属性来编写更高级别的列表行为–

class linked_list:
  ... 

  def length (self):
    if self.is_empty:
      return 0
    else:
      return 1 + self.tail.length()

上面，我们看到通过使用其属性来谈论我们的列表非常容易。 在继续之前，让我们看看如何构造列表并使用print对其进行可视化。 对于对象到字符串的转换，我们使用__str__ –

class linked_list:
  ... 

  def add (self, x):
    return linked_list (node (x, self))

  def __str__ (self):
    if self.is_empty:
      return "None"
    else:
      return str (self.head) + " -> " + str (self.tail)

ls = linked_list().add('A').add('B').add('C')
print (ls)
# C -> B -> A -> None

print (ls.length())
# 3

请记住，因为我们已经建立了一个不可改变的链接列表， add 不改变它呼吁名单-

ls = linked_list().add('A').add('B').add('C')
print (ls)
# C -> B -> A -> None

print (ls.add('D'))
# D -> C -> B -> A -> None

print (ls)
# C -> B -> A -> None

最后，我们可以实施reverse -

class linked_list:

  # ...

  def reverse (self):
    def loop (ls, acc):
      if ls.is_empty:
        return acc
      else:
        return loop (ls.tail, acc.add(ls.head))
    return loop (self, linked_list())

ls = linked_list().add('A').add('B').add('C')
print (ls)
# C -> B -> A -> None

print (ls.reverse())
# A -> B -> C -> None

反转列表不会使其突变

print (ls)
# C -> B -> A -> None

print (ls.reverse())
# A -> B -> C -> None

print (ls)
# C -> B -> A -> None