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

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

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

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

C++

// C++ program to sort a linked list,
// already sorted by absolute values
#include 
using namespace std;
 
// Linked List Node
struct Node
{
    Node* next;
    int data;
};
 
// Utility function to insert a
// node at the beginning
void push(Node** head, int data)
{
    Node* newNode = new Node;
    newNode->next = (*head);
    newNode->data = data;
    (*head) = newNode;
}
 
// Utility function to print
// a linked list
void printList(Node* head)
{
    while (head != NULL)
    {
        cout << head->data;
        if (head->next != NULL)
            cout << " -> ";
        head = head->next;
    }
    cout<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;
    }
}
 
// Driver code
int main()
{
    Node* head = NULL;
    push(&head, -5);
    push(&head, 5);
    push(&head, 4);
    push(&head, 3);
    push(&head, -2);
    push(&head, 1);
    push(&head, 0);
 
    cout << "Original list :";
    printList(head);
 
    sortList(&head);
 
    cout << "Sorted list :";
    printList(head);
 
    return 0;
}

输出：

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

时间复杂度： O(N)

辅助空间： O(1)

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