Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Python Program For Sorting Linked List Which Is Already Sorted On Absolute Values

  • Last Updated : 18 May, 2022

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. 

Python3




# Python3 program to sort a linked list, 
# already sorted by absolute values 
      
# Linked list Node
class Node:
    def __init__(self, d):
        self.data =
        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

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
Recommended Articles
Page :

Start Your Coding Journey Now!