使用遞歸逆轉單鏈表

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