# Point to next higher value node in a linked list with an arbitrary pointer

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 next greater value of 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 C implementation of 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.

```// C program to populate arbit pointers to next higher value
// using merge sort
#include<stdio.h>
#include<stdlib.h>

struct Node
{
int data;
struct Node* next, *arbit;
};

/* function prototypes */
struct Node* SortedMerge(struct Node* a, struct Node* b);
void FrontBackSplit(struct Node* source,
struct Node** frontRef, struct Node** backRef);

/* sorts the linked list formed by arbit pointers
(does not change next pointer or data) */
{
struct Node* a, *b;

/* Base case -- length 0 or 1 */
return;

/* Split head into 'a' and 'b' sublists */

/* Recursively sort the sublists */
MergeSort(&a);
MergeSort(&b);

/* answer = merge the two sorted lists together */
}

/* See http://www.geeksforgeeks.org/?p=3622 for details of this
function */
struct Node* SortedMerge(struct Node* a, struct Node* b)
{
struct Node* result = NULL;

/* Base cases */
if (a == NULL)
return (b);
else if (b==NULL)
return (a);

/* Pick either a or b, and recur */
if (a->data <= b->data)
{
result = a;
result->arbit = SortedMerge(a->arbit, b);
}
else
{
result = b;
result->arbit = SortedMerge(a, b->arbit);
}

return (result);
}

/* Split the nodes of the given list into front and back halves,
and return the two lists using the reference parameters.
If the length is odd, the extra node should go in the front list.
Uses the fast/slow pointer strategy.  */
void FrontBackSplit(struct Node* source,
struct Node** frontRef, struct Node** backRef)
{
struct Node* fast, *slow;

if (source==NULL || source->arbit==NULL)
{
/* length < 2 cases */
*frontRef = source;
*backRef = NULL;
return;
}

slow = source,  fast = source->arbit;

while (fast != NULL)
{
fast = fast->arbit;
if (fast != NULL)
{
slow = slow->arbit;
fast = fast->arbit;
}
}

/* 'slow' is before the midpoint in the list, so split it in two
at that point. */
*frontRef = source;
*backRef = slow->arbit;
slow->arbit = NULL;
}

/* Function to insert a node at the beginging of the linked list */
void push(struct Node** head_ref, int new_data)
{
/* allocate node */
struct Node* new_node =
(struct Node*) malloc(sizeof(struct Node));

/* put in the data  */
new_node->data  = new_data;

/* link the old list off the new node */

new_node->arbit = NULL;

/* move the head to point to the new node */
}

// Utility function to print result linked list
void printListafter(struct Node *node, struct Node *anode)
{
printf("Traversal using Next Pointer\n");
while (node!=NULL)
{
printf("%d, ", node->data);
node = node->next;
}

printf("\nTraversal using Arbit Pointer\n");
while (anode!=NULL)
{
printf("%d, ", anode->data);
anode = anode->arbit;
}
}

// This function populates arbit pointer in every node to the
// next higher value. And returns pointer to the node with
// minimum value
{
// Copy next pointers to arbit pointers
while (temp != NULL)
{
temp->arbit = temp->next;
temp = temp->next;
}

// Do merge sort for arbitrary pointers

}

/* Drier program to test above functions*/
int main()
{

/* Let us create the list shown above */

/* Sort the above created Linked List */

getchar();
return 0;
}
```

Output:

```Result Linked List is:
Traversal using Next Pointer
5, 10, 2, 3,
Traversal using Arbit Pointer
2, 3, 5, 10,```

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
3.4 Average Difficulty : 3.4/5.0
Based on 72 vote(s)