用于对已经按绝对值排序的链表进行排序的Python程序

给定一个基于绝对值排序的链表。根据实际值对列表进行排序。
例子：

Input:  1 -> -10 
Output: -10 -> 1

Input: 1 -> -2 -> -3 -> 4 -> -5 
Output: -5 -> -3 -> -2 -> 1 -> 4 

Input: -5 -> -10 
Output: -10 -> -5

Input: 5 -> 10 
Output: 5 -> 10

资料来源：亚马逊采访

一个简单的解决方案是从头到尾遍历链表。对于每个访问的节点，检查它是否出现故障。如果是，请将其从当前位置移除并插入到正确位置。这是链表插入排序的实现，这个解决方案的时间复杂度是O(n*n)。
更好的解决方案是使用归并排序对链表进行排序。该解决方案的时间复杂度为 O(n Log n)。
一个有效的解决方案可以在 O(n) 时间内工作。一个重要的观察结果是，所有负面元素都以相反的顺序存在。所以我们遍历链表，每当我们发现一个乱序的元素，我们就把它移到链表的最前面。
下面是上述思想的实现。

每当我们发现一个乱序的元素时，我们就把它移到链表的前面。
下面是上述思想的实现。

Python3

# Python3 program to sort a linked list,
# already sorted by absolute values
     
# Linked list Node
class Node:
    def __init__(self, d):
        self.data = d
        self.next = None
 
class SortList:
    def __init__(self):
        self.head = None
         
    # To sort a linked list by actual values.
    # The list is assumed to be sorted by
    # absolute values.
    def sortedList(self, head):
         
        # Initialize previous and
        # current nodes
        prev = self.head
        curr = self.head.next
         
        # Traverse list
        while(curr != None):
             
            # If curr is smaller than prev,
            # then it must be moved to head
            if(curr.data < prev.data):
                 
                # Detach curr from linked list
                prev.next = curr.next
                 
                # Move current node to beginning
                curr.next = self.head
                self.head = curr
                 
                # Update current
                curr = prev
             
            # Nothing to do if current element
            # is at right place
            else:
                prev = curr
         
            # Move current
            curr = curr.next
        return self.head
     
    # Inserts a new Node at front of
    # the list
    def push(self, new_data):
         
        # 1 & 2: Allocate the Node &
        #        Put in the data
        new_node = Node(new_data)
     
        # 3. Make next of new Node as head
        new_node.next = self.head
     
        # 4. Move the head to point to
        # new Node
        self.head = new_node
     
    # Function to print linked list
    def printList(self, head):
        temp = head
        while (temp != None):
            print(temp.data, end = " ")
            temp = temp.next
        print()
     
# Driver Code
llist = SortList()
 
# Constructed Linked List is 
# 1->2->3->4->5->6->7->8->8->9->null
llist.push(-5)
llist.push(5)
llist.push(4)
llist.push(3)
llist.push(-2)
llist.push(1)
llist.push(0)
         
print("Original List :")
llist.printList(llist.head)
         
start = llist.sortedList(llist.head)
 
print("Sorted list :")
llist.printList(start)
 
# This code is contributed by Prerna Saini

输出：

Original list :
0 -> 1 -> -2 -> 3 -> 4 -> 5 -> -5
Sorted list :
-5 -> -2 -> 0 -> 1 -> 3 -> 4 -> 5

时间复杂度： O(N)

辅助空间： O(1)

有关详细信息，请参阅已按绝对值排序的完整文章排序链表！