Rust में खोज: अधिकतम प्रदर्शन के साथ ऐरे एलिमेंट का इंडेक्स ढूँढना

परिचय: Rust में इंडेक्स खोज सिर्फ "ढूँढो और वापस करो" क्यों नहीं है?

Python या JavaScript से Rust में आने वाला हर डेवलपर देर-सबेर यह सवाल पूछता है: "यहाँ ऐरे या वेक्टर में एलिमेंट का इंडेक्स कैसे ढूँढूं?" Python में यह एक लाइन list.index(element) से होता है, JavaScript में — array.indexOf(element) से। लेकिन Rust, एक सच्चे परफेक्शनिस्ट की तरह, एक नहीं बल्कि कई तरीके प्रदान करता है, जिनमें से प्रत्येक के प्रदर्शन और सुरक्षा के अपने अलग-अलग पहलू हैं।

आइए समझते हैं कि Rust संग्रहों (ऐरे, वेक्टर और स्लाइस) में एलिमेंट का इंडेक्स कैसे खोजें ताकि कोड न केवल सही हो बल्कि तेज़ भी हो। आखिरकार, सिस्टम प्रोग्रामिंग में हर नैनोसेकंड मायने रखता है!

आधार: Rust में इंडेक्स खोजने के मुख्य तरीके

Rust की मानक लाइब्रेरी में इंडेक्स खोजने के लिए दो मुख्य "खिलाड़ी" हैं: position() और rposition()। ये किसी भी इटरेटर के लिए उपलब्ध हैं, और इसलिए ऐरे, वेक्टर और स्लाइस के लिए भी।

position() विधि: बाएँ से दाएँ खोज

position() एक क्लोजर लेता है और Option<usize> लौटाता है — शर्त को पूरा करने वाले पहले एलिमेंट का इंडेक्स, या यदि ऐसा कोई एलिमेंट नहीं मिलता है तो None लौटाता है।

fn main() {\n    let numbers = vec![10, 20, 30, 40, 50];\n    \n    // संख्या 30 की पहली उपस्थिति खोजें\n    let index = numbers.iter().position(|&x| x == 30);\n    \n    match index {\n        Some(i) => println!("संख्या 30 का इंडेक्स: {}", i), // आउटपुट: 2\n        None => println!("एलिमेंट नहीं मिला"),\n    }\n}\n

ध्यान दें: हम position() से पहले iter() कॉल कर रहे हैं। यह महत्वपूर्ण है, क्योंकि position() ट्रेट Iterator की विधि है, न कि स्वयं संग्रह की।

rposition() विधि: दाएँ से बाएँ खोज

यदि आपको एलिमेंट की अंतिम उपस्थिति का इंडेक्स चाहिए, तो rposition() का उपयोग करें। यह समान रूप से काम करता है, लेकिन संग्रह को अंत से शुरू करता है:

fn main() {\n    let data = vec!['a', 'b', 'c', 'b', 'a'];\n    \n    // 'b' की अंतिम उपस्थिति खोजें\n    let last_b = data.iter().rposition(|&c| c == 'b');\n    \n    println!("अंतिम 'b' इंडेक्स पर: {:?}", last_b); // Some(3)\n}\n

एक महत्वपूर्ण सीमा: rposition() केवल उन संग्रहों के साथ काम करता है जो द्विदिश ट्रैवर्सल (ट्रेट DoubleEndedIterator) का समर्थन करते हैं। सौभाग्य से, सभी मानक Rust संग्रह इस आवश्यकता को पूरा करते हैं।

प्रदर्शन तुलना: position() बनाम मैन्युअल लूप

कई शुरुआती मैन्युअल रूप से लूप लिखते हैं, यह सोचकर कि यह तेज़ होगा। आइए व्यवहार में इस धारणा की जाँच करें।

1 मिलियन पूर्णांकों वाले वेक्टर में एलिमेंट का इंडेक्स खोजने के दो तरीकों पर विचार करें:

use std::time::Instant;\n\nfn main() {\n    let large_vec: Vec<i32> = (0..1_000_000).collect();\n    let target = 999_999;\n    \n    // तरीका 1: position()\n    let start = Instant::now();\n    let pos1 = large_vec.iter().position(|&x| x == target);\n    let duration1 = start.elapsed();\n    println!("position(): {:?}, समय: {:?}", pos1, duration1);\n    \n    // तरीका 2: मैन्युअल लूप\n    let start = Instant::now();\n    let mut pos2 = None;\n    for (i, &val) in large_vec.iter().enumerate() {\n        if val == target {\n            pos2 = Some(i);\n            break;\n        }\n    }\n    let duration2 = start.elapsed();\n    println!("मैन्युअल लूप: {:?}, समय: {:?}", pos2, duration2);\n}\n

आधुनिक प्रोसेसर पर परिणाम आमतौर पर दिखाते हैं कि position() मैन्युअल लूप जितनी ही तेज़ी से काम करता है, और कभी-कभी Rust कंपाइलर (LLVM) के आंतरिक अनुकूलन के कारण और भी तेज़ होता है। निष्कर्ष: position() का उपयोग करें — यह मुहावरेदार, सुरक्षित है और गति में कोई कमी नहीं रखता।

बाइनरी सर्च: जब डेटा सॉर्ट किया गया हो

यदि आपका संग्रह सॉर्ट किया गया है, तो आपको binary_se