Data structures Python中的排序链表

我在弄清楚如何在Python中对单链表进行排序时遇到了一些困难。我已经知道了如何创建一个链表并将数据推送到链表上，但是如何以排序的格式推送到链表上（不是在所有数据推送到链表上后再排序），还是以任何方式对其进行排序

客观的 根据用户输入创建一个已排序的单链数字列表。 程序逻辑： 请求一个号码，将该号码添加到排序位置的列表中，然后打印列表。 重复此操作，直到输入-1作为数字

现行代码 我真的被困在这里了。提前感谢您的帮助

这应该可以做到：

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

class LinkedList:
  def __init__(self):
    self.head = None

  def addNode(self, data):
    curr = self.head
    if curr is None:
      n = Node()
      n.data = data
      self.head = n
      return

    if curr.data > data:
      n = Node()
      n.data = data
      n.next = curr
      self.head = n
      return

    while curr.next is not None:
      if curr.next.data > data:
        break
      curr = curr.next
    n = Node()
    n.data = data
    n.next = curr.next
    curr.next = n
    return

  def __str__(self):
    data = []
    curr = self.head
    while curr is not None:
      data.append(curr.data)
      curr = curr.next
    return "[%s]" %(', '.join(str(i) for i in data))

  def __repr__(self):
    return self.__str__()

def main():
  ll = LinkedList()
  num = int(input("Enter a number: "))
  while num != -1:
    ll.addNode(num)
    num = int(input("Enter a number: "))
  c = ll.head
  while c is not None:
    print(c.data)
    c = c.next

给予

---

我认为这是一个有点短，更容易

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

def main():
    nodes = []
    num = int(input("Enter number: "))
    while num != -1:
        nodes.append(Node(num))
        num = int(input("Enter number: "))

    # If list is empty then just end function
    if len(nodes) == 0: 
        return

    # Let python do the sorting
    nodes = sorted(nodes, key=lambda node: node.data)

    # Link the nodes together and print them while you're at it
    for i in range(len(nodes) - 1):
        nodes[i].next = nodes[i + 1]
        print(nodes[i].data)
    # We need to print the last node
    print(nodes[-1].data)

类节点：
定义初始化（自身，数据）：
self.data=int（数据）
self.next=无
类链接列表：
定义初始化（自）：
self.head=无
def asc_有序列表（自身、数据）：
新节点=节点（数据）
如果self.head为无：
self.head=新节点
返回
温度=自身水头
如果温度数据>数据：
new_node.next=temp
self.head=新节点
返回
而临时下一步：
如果temp.next.data>数据：
打破
温度=下一个温度
new_node.next=temp.next
temp.next=新节点
def描述有序列表（自身、数据）：
新节点=节点（数据）
如果self.head为无：
self.head=新节点
返回
温度=自身水头
如果数据>临时数据：
new_node.next=temp
self.head=新节点
返回
而临时下一步：
如果temp.data>data和temp.next.data

4年后，但我认为这样做更容易

 def append(self, value):
    new_node = Node(value)
    if self.head is None:
        self.head = new_node
    else:
        current = self.head
        while current is not None and current.value <= value:
            previous = current
            current = current.next
        if current is self.head:
            aux = self.head
            self.head = new_node
            new_node.next = aux
        else:
            previous.next = new_node
            new_node.next = current
    self.size += 1

def-append（self，value）：
新节点=节点（值）
如果self.head为无：
self.head=新节点
其他：
电流=自身磁头
而current不是None和current.value。抱歉，完全忘记了。谢谢你提醒我。全部完成。链表的尾部呢？这不是纯链表。您正在数组列表中实现一个链表。代码转储不能获得好的答案。您应该解释这是如何以及为什么解决他们的问题的。我建议你读书。”
class Node:
    def __init__(self, data, _next=None):
        self.data = data
        self.next = _next

def main():
    nodes = []
    num = int(input("Enter number: "))
    while num != -1:
        nodes.append(Node(num))
        num = int(input("Enter number: "))

    # If list is empty then just end function
    if len(nodes) == 0: 
        return

    # Let python do the sorting
    nodes = sorted(nodes, key=lambda node: node.data)

    # Link the nodes together and print them while you're at it
    for i in range(len(nodes) - 1):
        nodes[i].next = nodes[i + 1]
        print(nodes[i].data)
    # We need to print the last node
    print(nodes[-1].data)

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

class LinkedList:
    def __init__(self):
        self.head = None    

    def asc_ordered_list(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
            return

        temp = self.head
        if temp.data > data:
            new_node.next = temp
            self.head = new_node
            return

        while temp.next:
            if temp.next.data > data:
                break
            temp = temp.next

        new_node.next = temp.next
        temp.next = new_node

    def desc_ordered_list(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
            return

        temp = self.head
        if data > temp.data:
            new_node.next = temp
            self.head = new_node
            return

        while temp.next:
             if temp.data > data and temp.next.data < data:
                 break
             temp = temp.next

        new_node.next = temp.next
        temp.next = new_node

    def display_list(self):
        temp = self.head
        while temp is not None:
            print("data = {0}".format(temp.data))
            temp = temp.next

if __name__ == "__main__":
    llist = LinkedList()
    llist.desc_ordered_list(8)
    llist.desc_ordered_list(3)
    llist.desc_ordered_list(1)
    llist.desc_ordered_list(4)
    llist.desc_ordered_list(5)
    llist.desc_ordered_list(7)
    llist.desc_ordered_list(6)
    llist.desc_ordered_list(2) 
    llist.display_list()

class Solution:
    def sortList(self,node):

        if(node is None):
            return
        temp=node
        while(temp!=None):
            i=temp.next
            while(i!=None):
                if(temp.data>i.data):
                    n=i.data
                    i.data=temp.data
                    temp.data=n
                i=i.next
            temp=temp.next

 def append(self, value):
    new_node = Node(value)
    if self.head is None:
        self.head = new_node
    else:
        current = self.head
        while current is not None and current.value <= value:
            previous = current
            current = current.next
        if current is self.head:
            aux = self.head
            self.head = new_node
            new_node.next = aux
        else:
            previous.next = new_node
            new_node.next = current
    self.size += 1