C++ में दिए गए नंबर k से विभाज्य लिंक्ड लिस्ट के अधिकतम और न्यूनतम एलिमेंट

लिंक्ड लिस्ट एक रैखिक डेटा संरचना है जिसमें एलिमेंट्स पॉइंटर्स के माध्यम से जुड़े होते हैं। लिंक्ड लिस्ट के प्रत्येक एलिमेंट या नोड में एक डेटा भाग और लिंक होता है, या हम कह सकते हैं कि क्रम में अगले एलिमेंट का पॉइंटर होता है। एलिमेंट्स मेमोरी में नॉन-कंटीगुअस स्थान ले सकते हैं।

हमें एक सिंगली लिंक्ड लिस्ट दी गई है जिसमें एक डेटा भाग और अगले एलिमेंट का लिंक होता है। दूसरा इनपुट एक नंबर K है। कार्य एक लिंक्ड लिस्ट के अधिकतम और न्यूनतम एलिमेंट को ढूंढना है जो नंबर K से विभाज्य है। रैखिक लिंक्ड लिस्ट को केवल एक दिशा में पार किया जा सकता है। प्रत्येक नोड पर हम इसके डेटा भाग की K से विभाज्यता की जांच करेंगे। यदि वह नंबर अब तक मिला अधिकतम या न्यूनतम है तो हम MaxD और MinD के मानों को अपडेट करेंगे।

इनपुट

SList: 5→2→10→12→3→20→7, K=5

आउटपुट

Maximum element which is divisible by K: 20
Minimum element which is divisible by K: 5

व्याख्या - हेड नोड से पार करते हुए, डेटा भाग को K से विभाजित करते रहें और जांचें कि क्या यह पूरी तरह से विभाज्य है, यानी शेषफल 0 आता है।

केवल 5, 10 और 20, 5 से विभाज्य हैं जिनमें से 5 न्यूनतम और 20 अधिकतम है।

इनपुट

SList: 12→2→5→18→3→144→7, K=4

आउटपुट

Maximum element which is divisible by K: 144
Minimum element which is divisible by K: 12

केवल 12 और 144, 4 से विभाज्य हैं जिनमें से 12 न्यूनतम और 144 अधिकतम है।

नीचे दिए गए प्रोग्राम में उपयोग किया गया दृष्टिकोण

एक लिंक्ड लिस्ट नोड बनाएं। यहां हमने एक क्लास SLLnode बनाई है, जिसमें info भाग और next पॉइंटर है।
एक लिंक्ड लिस्ट बनाएं। यहां हमने एक क्लास SLList बनाई है जिसमें SLLnode ऑब्जेक्ट इसके सदस्य के रूप में है। तो SLList में SLLnodes होते हैं।
फंक्शन addtohead(int) इस लिस्ट में नोड्स जोड़ रहा है।
SLList में एलिमेंट्स जोड़ने के लिए हम SLList ऑब्जेक्ट LIST का उपयोग करके addtohead(int) कॉल कर रहे हैं।
एक बार SLList बन जाने के बाद हम फंक्शन Divisible(SLLnode*, int) को कॉल करते हैं जो दो इनपुट पैरामीटर्स लेता है: लिस्ट का हेड और इंटीजर K।
अब Divisible के अंदर हम दो वेरिएबल्स maxD और minD लेते हैं जो दिए गए नंबर K से विभाज्य लिंक्ड लिस्ट के अधिकतम और न्यूनतम एलिमेंट को संग्रहीत करते हैं।
maxD को -1 से और minD को 9999 से इनिशियलाइज़ किया जाता है। यह माना जाता है कि इनपुट किस रेंज में है।
फॉर लूप के अंदर हम हेड से शुरू करके लिंक्ड लिस्ट को पार करते हैं। इसके लिए वेरिएबल start हेड की ओर इंगित कर रहा है।
प्रत्येक नोड के info भाग की तुलना maxD और minD से करें और इसकी K से विभाज्यता जांचें। यदि वर्तमान नोड का info विभाज्य है और minD से कम है तो minD को वर्तमान info भाग से अपडेट करें।
यदि वर्तमान नोड का info K से विभाज्य है और maxD से बड़ा है, तो maxD को वर्तमान info भाग से अपडेट करें।
minD और maxD में प्राप्त परिणाम प्रिंट करें।

उदाहरण

#include <iostream>
using namespace std;

class SLLnode {
public:
    int info;
    SLLnode* next;
    SLLnode(int e1, SLLnode* ptr = nullptr) {
        info = e1;
        next = ptr;
    }
};

class SLList {
public:
    SLLnode* head;
    SLList() { head = nullptr; }
    void addtohead(int);
};

void SLList::addtohead(int el) {
    head = new SLLnode(el, head);
}

void Divisible(SLLnode* head, int K) {
    int minD = INT_MAX;
    int maxD = INT_MIN;
    SLLnode* start = head;
    bool found = false;
    
    for (start; start != nullptr; start = start->next) {
        if (start->info % K == 0) {
            found = true;
            if (start->info < minD) minD = start->info;
            if (start->info > maxD) maxD = start->info;
        }
    }
    
    if (found) {
        cout << "Max Element divisible by K: " << maxD << endl;
        cout << "Min Element divisible by K: " << minD << endl;
    } else {
        cout << "No element divisible by K found." << endl;
    }
}

// ड्राइवर कोड
int main() {
    SLList LIST;
    LIST.addtohead(50);
    LIST.addtohead(21);
    LIST.addtohead(32);
    LIST.addtohead(45);
    LIST.addtohead(11);
    LIST.addtohead(23);
    LIST.addtohead(90);
    LIST.addtohead(56);
    int K = 5;
    Divisible(LIST.head, K);
    return 0;
}

आउटपुट

Max Element divisible by K: 90
Min Element divisible by K: 45