Javascript Program For Pointing To Next Higher Value Node In A Linked List With An Arbitrary Pointer
Last Updated :
20 Mar, 2023
Given singly linked list with every node having an additional “arbitrary” pointer that currently points to NULL. Need to make the “arbitrary” pointer point to the next higher value node.
We strongly recommend to minimize your browser and try this yourself first
A Simple Solution is to traverse all nodes one by one, for every node, find the node which has the next greater value of the current node and change the next pointer. Time Complexity of this solution is O(n2).
An Efficient Solution works in O(nLogn) time. The idea is to use Merge Sort for linked list.
1) Traverse input list and copy next pointer to arbit pointer for every node.
2) Do Merge Sort for the linked list formed by arbit pointers.
Below is the implementation of the above idea. All of the merger sort functions are taken from here. The taken functions are modified here so that they work on arbit pointers instead of next pointers.
Javascript
<script>
var head;
class Node
{
constructor(val)
{
this .data = val;
this .arbit = null ;
this .next = null ;
}
}
function printList(node, anode)
{
document.write(
"Traversal using Next Pointer<br/>" );
while (node != null )
{
document.write(node.data + ", " );
node = node.next;
}
document.write(
"<br/>Traversal using Arbit Pointer<br/>" );
while (anode != null )
{
document.write(anode.data + ", " );
anode = anode.arbit;
}
}
function populateArbit(start)
{
var temp = start;
while (temp != null )
{
temp.arbit = temp.next;
temp = temp.next;
}
return MergeSort(start);
}
function MergeSort(start)
{
if (start == null ||
start.arbit == null )
{
return start;
}
var middle = getMiddle(start);
var nextofmiddle = middle.arbit;
middle.arbit = null ;
var left = MergeSort(start);
var right = MergeSort(nextofmiddle);
var sortedlist = SortedMerge(left,
right);
return sortedlist;
}
function getMiddle(source)
{
if (source == null )
return source;
var fastptr = source.arbit;
var slowptr = source;
while (fastptr != null )
{
fastptr = fastptr.arbit;
if (fastptr != null )
{
slowptr = slowptr.arbit;
fastptr = fastptr.arbit;
}
}
return slowptr;
}
function SortedMerge(a, b)
{
var result = null ;
if (a == null )
return b;
else if (b == null )
return a;
if (a.data <= b.data)
{
result = a;
result.arbit =
SortedMerge(a.arbit, b);
}
else
{
result = b;
result.arbit = SortedMerge(a, b.arbit);
}
return result;
}
head = new Node(5);
head.next = new Node(10);
head.next.next = new Node(2);
head.next.next.next = new Node(3);
var ahead = populateArbit(head);
document.write(
"Result Linked List is:<br/>" );
printList(head, ahead);
</script>
|
Output:
Result Linked List is:
Traversal using Next Pointer
5, 10, 2, 3,
Traversal using Arbit Pointer
2, 3, 5, 10,
Time Complexity: O(n log n), where n is the number of nodes in the Linked list.
Space Complexity: O(1). We are not using any extra space.
Please refer complete article on Point to next higher value node in a linked list with an arbitrary pointer for more details!
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...