std::vector में कोई तत्व है या नहीं, यह कैसे जाँचें? पूर्ण गाइड

परिचय: शाश्वत प्रश्न "क्या यह यहाँ है?"

कल्पना करें: आप C++ में एक गेम लिख रहे हैं, जहाँ आपको जाँचना है कि क्या खिलाड़ी के पास इन्वेंट्री में चाबी है। या आप लॉगिंग सिस्टम पर काम कर रहे हैं — आपको सुनिश्चित करना है कि उस ID वाला संदेश पहले से प्रोसेस नहीं हुआ है। या बस प्रोग्रामिंग का होमवर्क कर रहे हैं। और फिर — रुकिए। यह कैसे, भगवान के लिए, जल्दी से पता करें कि std::vector में कोई तत्व है या नहीं?

यह प्रश्न Stack Overflow पर सबसे लोकप्रिय में से एक है (दसियों हज़ार बार देखा गया!)। और यह व्यर्थ नहीं है। std::vector C++ का वर्कहॉर्स है, लेकिन इसमें Python या C# की तरह कोई अंतर्निहित .contains() विधि नहीं है। शुरुआती अक्सर भ्रमित हो जाते हैं। पेशेवर — इष्टतम तरीका चुनने में समय बर्बाद करते हैं।

इस लेख में हम वेक्टर में तत्व की उपस्थिति जाँचने के सभी मुख्य तरीकों पर चर्चा करेंगे: सबसे सरल और स्पष्ट से लेकर बाइनरी सर्च के साथ चालाक ट्रिक्स तक। आप जानेंगे कि कब किस विधि का उपयोग करना है, और फिर कभी अनुमान नहीं लगाएंगे। चलिए शुरू करते हैं!

विधि 1: शैली का क्लासिक — std::find

सबसे सीधा और समझने योग्य तरीका है हेडर फ़ाइल <algorithm> से एल्गोरिदम std::find का उपयोग करना। यह किसी भी डेटा प्रकार के लिए काम करता है जो तुलना ऑपरेटर == को सपोर्ट करता है।

तर्क सरल है: std::find वेक्टर की शुरुआत से अंत तक जाता है और पहले मिलने वाले तत्व पर एक इटरेटर लौटाता है। यदि तत्व नहीं मिलता है, तो यह vector.end() लौटाता है।

कोड उदाहरण:

#include <iostream>\n#include <vector>\n#include <algorithm> // std::find के लिए\n\nint main() {\n    std::vector<int> numbers = {10, 20, 30, 40, 50};\n    int target = 30;\n\n    // तत्व खोजें\n    auto it = std::find(numbers.begin(), numbers.end(), target);\n\n    if (it != numbers.end()) {\n        std::cout << "तत्व " << target << " मिल गया! (इंडेक्स: "\n                  << std::distance(numbers.begin(), it) << ")" << std::endl;\n    } else {\n        std::cout << "तत्व " << target << " नहीं मिला।" << std::endl;\n    }\n    return 0;\n}

लाभ: सरलता, स्पष्टता, किसी भी प्रकार (int, string, अपनी संरचनाएँ) के साथ काम करता है।

नुकसान: रैखिक जटिलता O(n)। यदि वेक्टर बड़ा है (लाखों तत्व), और आप बार-बार खोज करते हैं — यह धीमा है।

विधि 2: आवृत्तियाँ गिनें — std::count

कभी-कभी केवल "है या नहीं" जानना नहीं, बल्कि यह समझना ज़रूरी होता है कि तत्व कितनी बार आता है। इसके लिए std::count एकदम सही है। यह भी <algorithm> से है।

कोड उदाहरण:

#include <iostream>\n#include <vector>\n#include <algorithm>\n\nint main() {\n    std::vector<std::string> fruits = {"apple", "banana", "apple", "orange"};\n    std::string target = "apple";\n\n    int count = std::count(fruits.begin(), fruits.end(), target);\n\n    if (count > 0) {\n        std::cout << "फल '" << target << "' " << count << " बार मिला।" << std::endl;\n    } else {\n        std::cout << "फल मौजूद नहीं है।" << std::endl;\n    }\n    return 0;\n}

लाभ: पुनरावृत्तियों की संख्या बताता है। बहुत सरल भी।

नुकसान: वही रैखिक जटिलता O(n)। यदि आपको केवल "हाँ/नहीं" चाहिए, तो std::find पहले मिलान पर रुक सकता है, जबकि std::count पूरे वेक्टर को पार करेगा। इसलिए अस्तित्व की जाँच के लिए std::find थोड़ा तेज़ है।

विधि 3: सॉर्टिंग + बाइनरी सर्च (पेशेवरों के लिए)

यदि आप एक ही वेक्टर में कई बार तत्व खोजते हैं, तो अगले स्तर पर जाने का समय है। वेक्टर को एक बार सॉर्ट करें और std::binary_search का उपयोग करें। जटिलता — लॉगरिदमिक O(log n)। यह बड़े डेटा पर कई गुना तेज़ है।

महत्वपूर्ण शर्त:

वेक्टर सॉर्ट किया हुआ होना चाहिए।