如何在Python中递归地添加到链表中？

我在使用链表递归时遇到问题。 我希望能够将另一个节点添加到有序链表中

我有这门课：

class Link:
    def __init__(self,value,next=None):
        self.value = value
        self.next  = next

下面是递归函数，到目前为止，除了识别基本情况外，它没有做很多工作

注意：它不是

链接中的方法，而是一个单独的函数：

def add(ll, v):
    if ll == None:
        return Link(v)
    else:
         ll.next = add(ll.next,v)
         return ll

示例：我有一个链表
A
：

1->3->8->12->None

我调用
add（A，10）
，它应该按正确的顺序添加10

1->3->8->10->12->None

我应该如何修改代码以使其正常工作？
当您发现一个值不小于要按顺序插入的值时，您需要一个额外的基本情况来停止递归：

elif v <= ll.value:
    return Link(v, ll)

elif v当您发现一个值不小于要按顺序插入的值时，您需要一个额外的基本情况来停止递归：

elif v <= ll.value:
    return Link(v, ll)

elif v递归是一种函数遗产，因此将其与函数风格结合使用会产生最佳效果。我们先从最小的部分开始-

#linked_list.py
空=无
类节点：
def uuu init（self，value，next=empty）：
自我价值=价值
self.next=下一个
def to_str（ll=空）：
如果不是，我会：
返回“无”
其他：
返回f“{ll.value}->{to_str（ll.next）}”

#main.py
从链接列表导入节点，到链接列表
t=节点（1，节点（3，节点（8，节点（12）））
打印（至_街（t））
#1->3->8->12->无

现在我们实现
add
-

#linked_list.py
空=#。。。
类节点：#。。。
def to_str（ll=empty）：#。。。
def add（ll=空，v=0）：
如果不是，我会：
返回节点（v）
elif ll.value>=v:
返回节点（v，ll）
其他：
返回节点（ll.value，add（ll.next，v））
#main.py
从链接列表导入节点，到链接列表，添加
t=节点（1，节点（3，节点（8，节点（12）））
打印（至_街（t））
#1->3->8->12->无
t2=加（t，10）
打印（至_街（t2））
#1->3->8->10->12->无
现在我们来看看如何通过组合较小的位来生成较大的位。我们可以制作一个
链表
类来捆绑它-

#linked_list.py
空=#。。。
类节点：#。。。
def to_str（ll=empty）：#。。。
def add（ll=empty，v=0）：#。。。
类链接列表：
def uuu init uuu（self，root=empty）：
self.root=根
定义（自我）：
返回到_str（self.root）
def添加（自身，v）：
返回链接列表（添加（self.root，v））
现在我们可以在面向对象的风格中使用
链表
，但仍然可以获得函数式风格的持久好处-

#main.py
从链接列表导入链接列表
t=链表（）.add（1）.add（3）.add（8）.add（12）
打印（t）
#1->3->8->12->无
印刷品（t.add（10））
#1->3->8->10->12->无
打印（t）
#1->3->8->12->无

也许我们可以通过定义
从\u-list
和
到\u-list
来扩展我们的
链接\u-list
模块-

#linked_list.py
空=#。。。
类节点：#。。。
def to_str（ll=empty）：#。。。
def add（ll=empty，v=0）：#。。。
来自_列表的def（l=[]）：
如果不是l：
返回空
其他：
从_列表（l[1:]）返回节点（l[0]）
def to_列表（ll=空）：
如果不是，我会：
返回[]
其他：
将[ll.value]+返回到_列表（ll.next）
类链接列表：
定义初始化。。。
def_uuustr_uuu#。。。
def添加#。。。
来自_列表（l）的def：
返回链接的_列表（从_列表（l））
def to_列表（自身）：
返回到列表（self.root）
#main.py
从链接列表导入链接列表
t=链接列表。来自列表（[1,3,8,12]）
打印（t）
#1->3->8->12->无
印刷品（t.add（10））
#1->3->8->10->12->无
打印（t.add（11）.to_list（））
#[1,3,8,11,12]
递归是一种函数遗产，因此将其与函数风格结合使用会产生最佳效果。我们先从最小的部分开始-

#linked_list.py
空=无
类节点：
def uuu init（self，value，next=empty）：
自我价值=价值
self.next=下一个
def to_str（ll=空）：
如果不是，我会：
返回“无”
其他：
返回f“{ll.value}->{to_str（ll.next）}”

#main.py
从链接列表导入节点，到链接列表
t=节点（1，节点（3，节点（8，节点（12）））
打印（至_街（t））
#1->3->8->12->无

现在我们实现
add
-

#linked_list.py
空=#。。。
类节点：#。。。
def to_str（ll=empty）：#。。。
def add（ll=空，v=0）：
如果不是，我会：
返回节点（v）
elif ll.value>=v:
返回节点（v，ll）
其他：
返回节点（ll.value，add（ll.next，v））
#main.py
从链接列表导入节点，到链接列表，添加
t=节点（1，节点（3，节点（8，节点（12）））
打印（至_街（t））
#1->3->8->12->无
t2=加（t，10）
打印（至_街（t2））
#1->3->8->10->12->无
现在我们来看看如何通过组合较小的位来生成较大的位。我们可以制作一个
链表
类来捆绑它-

#linked_list.py
空=#。。。
类节点：#。。。
def to_str（ll=empty）：#。。。
def add（ll=empty，v=0）：#。。。
类链接列表：
def uuu init uuu（self，root=empty）：
self.root=根
定义（自我）：
返回到_str（self.root）
def添加（自身，v）：
返回链接列表（添加（self.root，v））
现在我们可以在面向对象的风格中使用
链表
，但仍然可以获得函数式风格的持久好处-

#main.py
从链接列表导入链接列表
t=链表（）.add（1）.add（3）.add（8）.add（12）
打印（t）
#1->3->8->12->无
印刷品（t.add（10））
#1->3->8->10->12->无
打印（t）
#1->3->8->12->无

也许我们可以通过定义
从\u-list
和
到\u-list
来扩展我们的
链接\u-list
模块-

#linked_list.py
空=#。。。
类节点：#。。。
def to_str（ll=empty）：#。。。
def add（ll=empty，v=0）：#。。。
来自_列表的def（l=[]）：
如果不是l：
返回空
其他：
从_列表（l[1:]）返回节点（l[0]）
def to_列表（ll=空）：
如果不是，我会：
返回[]
其他：
将[ll.value]+返回到_列表（ll.next）
类链接列表：
定义初始化。。。
def_uuustr_uuu#。。。
def添加#。。。
来自_列表（l）的def：
返回链接的_列表（从_列表（l））
def to_列表（自身）：
返回到列表（self.root）
#ma