 GeeksforGeeks App
Open App Browser
Continue

# C++ Program For Sorting Linked List Which Is Already Sorted On Absolute Values

Given a linked list that is sorted based on absolute values. Sort the list based on actual values.
Examples:

```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```

Source : Amazon Interview

A simple solution is to traverse the linked list from beginning to end. For every visited node, check if it is out of order. If it is, remove it from its current position and insert it at the correct position. This is the implementation of insertion sort for linked list and the time complexity of this solution is O(n*n).
A better solution is to sort the linked list using merge sort. Time complexity of this solution is O(n Log n).
An efficient solution can work in O(n) time. An important observation is, all negative elements are present in reverse order. So we traverse the list, whenever we find an element that is out of order, we move it to the front of the linked list.
Below is the implementation of the above idea.

ever we find an element that is out of order, we move it to the front of the linked list.
Below is the implementation of the above idea.

## 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;``}`

Output:

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

Time Complexity: O(N)

Auxiliary Space: O(1)

Please refer complete article on Sort linked list which is already sorted on absolute values for more details!

My Personal Notes arrow_drop_up