Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> C++

C++ में लिंक्ड लिस्ट में मनमाना पॉइंटर को अगले उच्च मान वाले नोड पर इंगित करना


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

समस्या को समझने के लिए एक उदाहरण लेते हैं,

C++ में लिंक्ड लिस्ट में मनमाना पॉइंटर को अगले उच्च मान वाले नोड पर इंगित करना

यहां, हम देख सकते हैं 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,
  1. C++ में मल्टीलेवल लिंक्ड सूची को समतल करना C++ में मल्टीलेवल लिंक्ड सूची को समतल करना

    इस समस्या में, हमें एक मल्टीलेवल लिंक्ड सूची दी गई है। हमारा कार्य मल्टीलेवल लिंक्ड सूची को समतल करने के लिए एक प्रोग्राम बनाना है। समतल करने का ऑपरेशन इस तरह से किया जाता है कि पहले स्तर के नोड्स पहले लिंक्ड सूची में आएंगे और फिर दूसरे स्तर के नोड्स आएंगे। मल्टीलेवल लिंक्ड सूची एक बहुआयामी डेटा संर

  1. C++ में रैंडम पॉइंटर के साथ लिस्ट कॉपी करें C++ में रैंडम पॉइंटर के साथ लिस्ट कॉपी करें

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

  1. C++ में लिंक्ड लिस्ट में मनमाना पॉइंटर को दाईं ओर के सबसे बड़े मान वाले नोड पर इंगित करना C++ में लिंक्ड लिस्ट में मनमाना पॉइंटर को दाईं ओर के सबसे बड़े मान वाले नोड पर इंगित करना

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