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

तीन लिंक्ड लिस्ट में सामान्य तत्व खोजें C++ में

मान लीजिए हमारे पास तीन लिंक्ड लिस्ट हैं। हमें उन सभी सामान्य तत्वों को खोजना है जो इन तीनों लिंक्ड लिस्ट में मौजूद हैं। मान लीजिए ये सूचियां [10, 12, 15, 20, 25], [10, 12, 13, 15] और [10, 12, 15, 24, 25, 26] हैं, तो इन तीनों सूचियों में सामान्य तत्व 10, 12 और 15 हैं।

हम इस समस्या को हल करने के लिए हैशिंग तकनीक का उपयोग करेंगे। इसे हल करने के लिए, हमें इन चरणों का पालन करना होगा -

  • एक खाली हैश टेबल बनाएं, और पहली सूची में प्रत्येक तत्व से गुजरें, और तत्वों को डालें, और फ्रीक्वेंसी को 1 के रूप में मार्क करें

  • दूसरी लिंक्ड लिस्ट के माध्यम से पुनरावृति करें, फिर यदि तत्व के लिए वर्तमान फ्रीक्वेंसी 1 है, तो इसे 2 बनाएं

  • तीसरी लिंक्ड लिस्ट के माध्यम से पुनरावृति करें, फिर यदि तत्व के लिए वर्तमान फ्रीक्वेंसी 2 है, तो इसे 3 बनाएं

  • अब पहली सूची के माध्यम से फिर से पुनरावृति करें ताकि तत्वों की फ्रीक्वेंसी जांच सकें, यदि कोई तत्व है जिसकी फ्रीक्वेंसी 3 है, तो उस तत्व को प्रिंट करें, और अगले के लिए जाएं

उदाहरण

#include <iostream>
#include <cmath>
#include <unordered_map>
using namespace std;

class Node {
public:
    int data;
    Node* next;
};

void addNode(Node** start, int data) {
    Node* newNode = new Node;
    newNode->data = data;
    newNode->next = (*start);
    (*start) = newNode;
}

void findCommonValues(Node* list1, Node* list2, Node* list3) {
    unordered_map<int, int> hash;
    Node* p = list1;
    while (p != NULL) {
        hash[p->data] = 1;
        p = p->next;
    }
    Node* q = list2;
    while (q != NULL) {
        if (hash.find(q->data) != hash.end()) hash[q->data] = 2;
        q = q->next;
    }
    Node* r = list3;
    while (r != NULL) {
        if (hash.find(r->data) != hash.end() && hash[r->data] == 2)
            hash[r->data] = 3;
        r = r->next;
    }
    for (auto x : hash) {
        if (x.second == 3)
            cout << x.first << " ";
    }
}

int main() {
    Node* list1 = NULL;
    addNode(&list1, 10);
    addNode(&list1, 12);
    addNode(&list1, 15);
    addNode(&list1, 20);
    addNode(&list1, 25);
    Node* list2 = NULL;
    addNode(&list2, 10);
    addNode(&list2, 12);
    addNode(&list2, 13);
    addNode(&list2, 15);
    Node* list3 = NULL;
    addNode(&list3, 10);
    addNode(&list3, 12);
    addNode(&list3, 15);
    addNode(&list3, 24);
    addNode(&list3, 25);
    addNode(&list3, 26);
    cout << "Common elements are: ";
    findCommonValues(list1, list2, list3);
}

आउटपुट

Common elements are: 10 12 15

  1. - C++ में लिंक्ड लिस्ट में मॉड्यूलर नोड ढूंढना

    इस समस्या में, हमें एक सिंगली लिंक्ड लिस्ट LL और एक संख्या k दी जाती है। हमारा कार्य लिंक्ड लिस्ट में मॉड्यूलर नोड ढूंढना है।समस्या विवरण – हमें लिंक्ड लिस्ट के अंतिम नोड को ढूंढना है जिसके लिए इंडेक्स k से विभाज्य है यानी i % k == 0।आइए एक उदाहरण से समस्या को समझते हैं,इनपुट 2, k = 4आउटपुट6व्याख्या

  1. - C++ में रेंज के लापता तत्व ढूंढना

    इस समस्या में, हमें आकार n की एक सरणी arr[] और रेंज को दर्शाने वाले प्रारंभ और अंत तत्व दिए जाते हैं। हमारा कार्य रेंज के लापता तत्व ढूंढना है।समस्या विवरण – हम रेंज के उन तत्वों को ढूंढेंगे जो रेंज में मौजूद नहीं हैं।आइए एक उदाहरण से समस्या को समझते हैं,इनपुटarr[] = {4, 6, 3, 7}, start = 3, end = 8

  1. C++ में दो लिंक्ड लिस्ट का इंटरसेक्शन C++ में दो लिंक्ड लिस्ट का इंटरसेक्शन

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