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

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

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) 时间内工作。一个重要的观察结果是，所有负面元素都以相反的顺序存在。所以我们遍历链表，每当我们发现一个乱序的元素，我们就把它移到链表的最前面。
下面是上述思想的实现。

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

Java

// Java program to sort a linked list,
// already sorted by absolute values
class SortList
{
    // Head of list
    static Node head; 
   
    // Linked list Node
    static class Node
    {
        int data;
        Node next;
        Node(int d)
        {
            data = d;
            next = null;
        }
    }
     
    // To sort a linked list by actual values.
    // The list is assumed to be sorted by
    // absolute values.
    Node sortedList(Node head)
    {
        // Initialize previous and current
        // nodes
        Node prev = head;
        Node curr = head.next;
         
        // Traverse list
        while(curr != null)
        {
            // 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 = head;
                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 head;
    }
     
    /* Inserts a new Node at front of
       the list. */
    public void push(int new_data)
    {
        /* 1 & 2: Allocate the Node &
                  Put in the data*/
        Node new_node = new Node(new_data);
   
        // 3. Make next of new Node as head
        new_node.next = head;
   
        // 4. Move the head to point
        // to new Node
        head = new_node;
    }
     
    // Function to print linked list
    void printList(Node head)
    {
        Node temp = head;
        while (temp != null)
        {
           System.out.print(temp.data + " ");
           temp = temp.next;
        } 
        System.out.println();
    }
     
    // Driver code
    public static void main(String args[])
    {
        SortList llist = new 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);
          
        System.out.println("Original List :");
        llist.printList(llist.head);
          
        llist.head = llist.sortedList(head);
  
        System.out.println("Sorted list :");
        llist.printList(llist.head);
    }
}
 
// This code is contributed by Amit Khandelwal(Amit Khandelwal 1).

输出：

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

时间复杂度： O(N)

辅助空间： O(1)

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