इस समस्या में, हमें एक लिंक्ड लिस्ट दी गई है जिसमें एक मान, लिंक पॉइंटर और एक मनमाना पॉइंटर है। हमारा कार्य मनमाना पॉइंटर को सूची में अगले बड़े मान की ओर इंगित करना है।
समस्या को समझने के लिए एक उदाहरण लेते हैं,

यहां, हम देख सकते हैं 8 12 की ओर इंगित करता है, 12 41 की ओर, 41 54 की ओर, 54 76 की ओर जो लिंक्ड लिस्ट के क्रमिक बड़े तत्व हैं।
इस समस्या को हल करने के लिए, हम तत्वों को सॉर्ट करने के लिए मर्ज सॉर्ट एल्गोरिदम का उपयोग करेंगे और मनमाना पॉइंटर के लिए सॉर्ट को लिंक्ड लिस्ट के रूप में उपयोग करेंगे।
इसके लिए हम लिंक्ड लिस्ट पर मर्ज सॉर्ट एल्गोरिदम का उपयोग करेंगे मनमाना पॉइंटर को सॉर्टिंग के लिए प्राथमिक पॉइंटर मानकर और लिंक्ड लिस्ट, यह समस्या हल हो जाएगी यानी प्रत्येक मनमाना पॉइंटर उसके बाद के अगले बड़े नोड की ओर इंगित करेगा।
उदाहरण
हमारे समाधान के कार्यान्वयन को दर्शाने वाला प्रोग्राम,
#include <iostream>
using namespace std;
class Node {
public:
int data;
Node* next, *arbit;
};
Node* SortedMerge(Node* a, Node* b);
void FrontBackSplit(Node* source, Node** frontRef, Node** backRef);
void MergeSort(Node** headRef) {
Node* head = *headRef;
Node* a, *b;
if ((head == NULL) || (head->arbit == NULL))
return;
FrontBackSplit(head, &a, &b);
MergeSort(&a);
MergeSort(&b);
*headRef = SortedMerge(a, b);
}
Node* SortedMerge(Node* a, Node* b) {
Node* 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);
}
void FrontBackSplit(Node* source, Node** frontRef, Node** backRef) {
Node* fast, *slow;
if (source == NULL || source->arbit == NULL) {
*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;
}
}
*frontRef = source;
*backRef = slow->arbit;
slow->arbit = NULL;
}
void addNode(Node** head_ref, int new_data) {
Node* new_node = new Node();
new_node->data = new_data;
new_node->next = (*head_ref);
new_node->arbit = NULL;
(*head_ref) = new_node;
}
Node* populateArbitraray(Node *head) {
Node *temp = head;
while (temp != NULL) {
temp->arbit = temp->next;
temp = temp->next;
}
MergeSort(&head);
return head;
}
int main() {
Node* head = NULL;
addNode(&head, 45);
addNode(&head, 12);
addNode(&head, 87);
addNode(&head, 32);
Node *ahead = populateArbitraray(head);
cout << "\t\tमनमाना पॉइंटर ओवरलोडेड \n लिंक्ड लिस्ट ट्रैवर्स कर रहे हैं\n";
cout << "नेक्स्ट पॉइंटर का उपयोग करके\n";
while (head != NULL) {
cout << head->data << ", ";
head = head->next;
}
printf("\nमनमाना पॉइंटर का उपयोग करके\n");
while (ahead != NULL) {
cout << ahead->data << ", ";
ahead = ahead->arbit;
}
return 0;
}
आउटपुट
मनमाना पॉइंटर ओवरलोडेड लिंक्ड लिस्ट ट्रैवर्स कर रहे हैं नेक्स्ट पॉइंटर का उपयोग करके 32, 87, 12, 45, मनमाना पॉइंटर का उपयोग करके 12, 32, 45, 87,