Javascript Program For QuickSort On Singly Linked List
Last Updated :
03 May, 2023
QuickSort on Doubly Linked List is discussed here. QuickSort on Singly linked list was given as an exercise. The important things about implementation are, it changes pointers rather swapping data and time complexity is same as the implementation for Doubly Linked List.
In partition(), we consider last element as pivot. We traverse through the current list and if a node has value greater than pivot, we move it after tail. If the node has smaller value, we keep it at its current position.
In QuickSortRecur(), we first call partition() which places pivot at correct position and returns pivot. After pivot is placed at correct position, we find tail node of left side (list before pivot) and recur for left list. Finally, we recur for right list.
Javascript
<script>
class Node
{
constructor(val)
{
this.data = val;
this.next = null;
}
}
var head;
function addNode(data)
{
if (head == null)
{
head = new Node(data);
return;
}
var curr = head;
while (curr.next != null)
curr = curr.next;
var newNode = new Node(data);
curr.next = newNode;
}
function printList(n)
{
while (n != null)
{
document.write(n.data);
document.write(" ");
n = n.next;
}
}
function partitionLast(start, end)
{
if (start == end ||
start == null ||
end == null)
return start;
var pivot_prev = start;
var curr = start;
var pivot = end.data;
while (start != end)
{
if (start.data < pivot)
{
pivot_prev = curr;
var temp = curr.data;
curr.data = start.data;
start.data = temp;
curr = curr.next;
}
start = start.next;
}
var temp = curr.data;
curr.data = pivot;
end.data = temp;
return pivot_prev;
}
function sort(start, end)
{
if (start == null ||
start == end ||
start == end.next)
return;
var pivot_prev = partitionLast(start, end);
sort(start, pivot_prev);
if (pivot_prev != null &&
pivot_prev == start)
sort(pivot_prev.next, end);
else if (pivot_prev != null &&
pivot_prev.next != null)
sort(pivot_prev.next.next, end);
}
addNode(30);
addNode(3);
addNode(4);
addNode(20);
addNode(5);
var n = head;
while (n.next != null)
n = n.next;
document.write(
"Linked List before sorting<br/>");
printList(head);
sort(head, n);
document.write(
"<br/>Linked List after sorting<br/>");
printList(head);
</script>
|
Output:
Linked List before sorting
30 3 4 20 5
Linked List after sorting
3 4 5 20 30
Time Complexity: O(N * log N), It takes O(N2) time in the worst case and O(N log N) in the average or best case.
Please refer complete article on QuickSort on Singly Linked List for more details!
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...