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++
#include <bits/stdc++.h>
using namespace std;
struct Node
{
Node* next;
int data;
};
void push(Node** head, int data)
{
Node* newNode = new Node;
newNode->next = (*head);
newNode->data = data;
(*head) = newNode;
}
void printList(Node* head)
{
while (head != NULL)
{
cout << head->data;
if (head->next != NULL)
cout << " -> " ;
head = head->next;
}
cout<<endl;
}
void sortList(Node** head)
{
Node* prev = (*head);
Node* curr = (*head)->next;
while (curr != NULL)
{
if (curr->data < prev->data)
{
prev->next = curr->next;
curr->next = (*head);
(*head) = curr;
curr = prev;
}
else
prev = curr;
curr = curr->next;
}
}
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
class SortList
{
static Node head;
static class Node
{
int data;
Node next;
Node( int d) {data = d; next = null ; }
}
Node sortedList(Node head)
{
Node prev = head;
Node curr = head.next;
while (curr != null )
{
if (curr.data < prev.data)
{
prev.next = curr.next;
curr.next = head;
head = curr;
curr = prev;
}
else
prev = curr;
curr = curr.next;
}
return head;
}
public void push( int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
void printList(Node head)
{
Node temp = head;
while (temp != null )
{
System.out.print(temp.data+ " " );
temp = temp.next;
}
System.out.println();
}
public static void main(String args[])
{
SortList llist = new SortList();
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);
}
}
|
Python3
class Node:
def __init__( self , d):
self .data = d
self . next = None
class SortList:
def __init__( self ):
self .head = None
def sortedList( self , head):
prev = self .head
curr = self .head. next
while (curr ! = None ):
if (curr.data < prev.data):
prev. next = curr. next
curr. next = self .head
self .head = curr
curr = prev
else :
prev = curr
curr = curr. next
return self .head
def push( self , new_data):
new_node = Node(new_data)
new_node. next = self .head
self .head = new_node
def printList( self , head):
temp = head
while (temp ! = None ):
print (temp.data, end = " " )
temp = temp. next
print ()
llist = SortList()
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)
|
C#
using System;
public class SortList
{
Node head;
class Node
{
public int data;
public Node next;
public Node( int d)
{
data = d; next = null ;
}
}
Node sortedList(Node head)
{
Node prev = head;
Node curr = head.next;
while (curr != null )
{
if (curr.data < prev.data)
{
prev.next = curr.next;
curr.next = head;
head = curr;
curr = prev;
}
else
prev = curr;
curr = curr.next;
}
return head;
}
public void push( int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
void printList(Node head)
{
Node temp = head;
while (temp != null )
{
Console.Write(temp.data + " " );
temp = temp.next;
}
Console.WriteLine();
}
public static void Main(String []args)
{
SortList llist = new SortList();
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);
}
}
|
Javascript
<script>
var head;
class Node {
constructor(d) {
this .data = d;
this .next = null ;
}
}
function sortedList(head) {
var prev = head;
var curr = head.next;
while (curr != null ) {
if (curr.data < prev.data) {
prev.next = curr.next;
curr.next = head;
head = curr;
curr = prev;
}
else
prev = curr;
curr = curr.next;
}
return head;
}
function push(new_data) {
var new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
function printList(head) {
var temp = head;
while (temp != null ) {
document.write(temp.data + " " );
temp = temp.next;
}
document.write( "<br/>" );
}
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);
</script>
|
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)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...