Sort linked list which is already sorted on absolute values
Last Updated :
02 Jun, 2023
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.
C++
// C++ program to sort a linked list, already
// sorted by absolute values
#include <bits/stdc++.h>
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<<endl;
}
// To sort a linked list by actual values.
// The list is assumed to be sorted by absolute
// values.
void sortList(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;
}
}
// 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 :\n";
printList(head);
sortList(&head);
cout << "\nSorted list :\n";
printList(head);
return 0;
}
// Java program to sort a linked list, already
// sorted by absolute values
class SortList
{
static Node head; // head of list
/* 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 program to test above functions */
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 has been contributed by Amit Khandelwal(Amit Khandelwal 1).
# 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
// C# program to sort a linked list, already
// sorted by absolute values
using System;
public class SortList
{
Node head; // head of list
/* Linked list Node*/
class Node
{
public int data;
public Node next;
public 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)
{
Console.Write(temp.data + " ");
temp = temp.next;
}
Console.WriteLine();
}
/* 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);
Console.WriteLine("Original List :");
llist.printList(llist.head);
llist.head = llist.sortedList(llist.head);
Console.WriteLine("Sorted list :");
llist.printList(llist.head);
}
}
/* This code is contributed by 29AjayKumar */
<script>
// Javascript program to sort a linked list, already
// sorted by absolute values
var head; // head of list
/* Linked list Node */
class Node {
constructor(d) {
this.data = d;
this.next = null;
}
}
// To sort a linked list by actual values.
// The list is assumed to be sorted by absolute
// values.
function sortedList(head) {
// Initialize previous and current nodes
var prev = head;
var 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. */
function push(new_data) {
/*
* 1 & 2: Allocate the Node & Put in the data
*/
var 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 */
function printList(head) {
var temp = head;
while (temp != null) {
document.write(temp.data + " ");
temp = temp.next;
}
document.write("<br/>");
}
/* Driver program to test above functions */
/*
Constructed Linked List is
1->2->3->4->5->6-> 7->8->8->9->null
*/
push(-5);
push(5);
push(4);
push(3);
push(-2);
push(1);
push(0);
document.write("Original List :<br/>");
printList(head);
head = sortedList(head);
document.write("Sorted list :<br/>");
printList(head);
// This code contributed by aashish1995
</script>
OutputOriginal 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)
Similar Reads
Javascript 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 -> 1Input: 1 -> -2 -> -3 -> 4 -> -5 Output: -5 -> -3 -> -2 -> 1 -> 4 Input: -5 -> -10 Output: -10 -> -5Input: 5 -> 10 Output:
3 min read
Sort given Array which is already Sorted based on absolute values of elements Given an array arr[] of size N, sorted based on the absolute value of its elements. The task is to sort this array based on the actual values of the elements. Examples: Input: arr[] = {5, -7, 10, -11, 18}Output: -11, -7, 5, 10, 18Explanation: When the array is sorted the negative values will come at
7 min read
Sort Array according to modulus of their values with their frequencies Given an array arr containing N positive integers, sort them according to the increasing modulus of their values with their frequencies. Example: Input: arr[]={1, 1, 5, 3, 2, 3, 3, 3, 4, 5, 4, 5}Output: 2 4 4 1 1 5 5 5 3 3 3 3 Explanation:The elements are sorted in the following order:2 % frequency(
6 min read
Sort given Array based on the fractional values Given an array arr[] that contains N real numbers. The task is to sort the array in decreasing order of the Fractional Values Note: If the values of the fractional part are same then sort those elements in Decreasing order of their Integer Values. Examples: Input: arr[] = { 8.33, -3.85, 1.999, 6.33,
10 min read
Sort an array according to absolute difference with a given value "using constant extra space" Given an array of n distinct elements and a number x, arrange array elements according to the absolute difference with x, i. e., element having minimum difference comes first and so on, using constant extra space. Note : If two or more elements are at equal distance arrange them in same sequence as
7 min read
Check if Array can be sorted by changing elements to Absolute difference with j Given an array of positive numbers arr[] of size n, the task is to check if we can make the array sorted in non-decreasing order by choosing any positive integer j and changing all elements of the array a[i] to abs(a[i]-j). Examples: Input: arr = { 3, 3, 1 }Output: Yes Explanation: We can make array
7 min read
Bucket Sort To Sort an Array with Negative Numbers We have discussed bucket sort in the main post on Bucket Sort . Bucket sort is mainly useful when input is uniformly distributed over a range. For example, consider the problem of sorting a large set of floating point numbers which are in range from 0.0 to 1.0 and are uniformly distributed across th
9 min read
Python | Sort an array according to absolute difference Given an array of N distinct elements and a number val, rearrange the array elements according to the absolute difference with val, i. e., element having minimum difference comes first and so on. Also the order of array elements should be maintained in case two or more elements have equal difference
3 min read
How to Sort a Set of Values in Python? Sorting means arranging the set of values in either an increasing or decreasing manner. There are various methods to sort values in Python. We can store a set or group of values using various data structures such as list, tuples, dictionaries which depends on the data we are storing. We can sort val
7 min read
Add elements in start to sort the array | Variation of Stalin Sort Stalin sort (also 'dictator sort' and 'trump sort') is a nonsensical 'sorting' algorithm in which each element that is not in the correct order is simply eliminated from the list. This sorting algorithm is a less destructive variation of Stalin sort, that will actually sort the list: In this case, t
6 min read