Sorting a Singly Linked List

Last Updated : 19 Sep, 2024

Given a singly Linked List, the task is to sort this Linked List in non-decreasing order.

Examples:

Input: 10->30->20->5
Output: 5->10->20->30
Explanation: The above linked list is sorted in non-decreasing order.
Input: 20->4->3
Output: 3->4->20
Explanation: The above linked list is sorted in non-decreasing order.

Table of Content

Sort Linked List using Bubble Sort

To apply Bubble Sort to a linked list, we need to traverse the list multiple times, comparing adjacent nodes and swapping their positions by adjusting their links if the current node’s data is greater than the next. During each pass, the largest unsorted element moves to its correct position at the end of the list. This process continues until no more swaps are needed, indicating that the list is sorted. Please refer to Bubble Sort for Linked List for implementation.

Time complexity: O(n^2) , where n is the number of nodes in the Linked List.
Auxiliary space: O(1)

Sort Linked List using Insertion Sort

The algorithm for sorting a linked list using Insertion Sort involves gradually building a sorted portion of the list within the same memory space. For each node, the algorithm determines its correct position within the sorted list. If the node is smaller than the current head of the sorted list, it becomes the new head. Otherwise, it is inserted into its appropriate position by traversing the sorted list. This process is repeated until all nodes are correctly positioned, resulting in the sorted list. Please refer to Insertion Sort for Singly Linked List for implementation.

Time Complexity: O(n²), In the worst case, we might have to traverse all nodes of the sorted list for inserting a node.
Auxiliary Space: O(1), no extra space is required.

Sort Linked List using Quick Sort

Quick Sort is a highly efficient divide-and-conquer algorithm used for sorting linked lists. The algorithm operates by selecting a pivot element from the list and partitioning the remaining elements into two sublists, one containing elements smaller than the pivot and the other with elements larger. This partitioning step ensures that elements are grouped around the pivot, with all elements smaller placed before it and all larger placed after the pivot. The algorithm then recursively applies the same process to the sublists, progressively sorting the entire list. Please refer to QuickSort on Singly Linked List for implementation.

Time Complexity: O(n * log n), It takes O(n²) time in the worst case and O(n log n) in the average or best case.
Auxiliary Space: O(n)

Sort Linked List using Merge Sort

Merge Sort is a divide-and-conquer algorithm that splits the array into two halves, recursively sorts each half, and then merges the sorted halves back together. It requires additional memory to store temporary subarrays during the merge process. The algorithm repeatedly splits and merges until the entire array is sorted. Please refer to Merge Sort for Linked Lists for implementation.

Which Sorting Algorithm is best for Linked Lists?

For linked lists, Merge Sort is often the best choice because:

Merge Sort guarantees a time complexity of O(nlogn) in the average, best, and worst cases.
Merge Sort is Stable
Merge Sort naturally fits well with Linked List because it traverses items in sequential manner (no random access)
When we compare linked list implementation with the array implementation we can notice that the linked list implementation does not require extra space to merge because linked list allows insertion and deletion in the middle in O(1) time.

Alternate sorting of Linked list

RishabhPrabhu

Improve

Article Tags :

Practice Tags :