Rust में वेक्टरों की सॉर्टिंग: उदाहरणों के साथ शुरुआती लोगों के लिए पूर्ण गाइड

Rust में वेक्टर को कैसे सॉर्ट करें: शुरुआती से विशेषज्ञ तक

कल्पना करें: आप Rust में एक प्रोग्राम लिख रहे हैं जो उपयोगकर्ताओं की सूची एकत्र करता है — नाम, आयु, रेटिंग। डेटा अव्यवस्थित क्रम में आता है। आपको उन्हें वर्णमाला क्रम में या, मान लीजिए, आयु के अनुसार सॉर्ट करके प्रदर्शित करना है। परिचित समस्या है? यदि आपने Stack Overflow पर देखा है, तो आपने निश्चित रूप से "How to sort a vector in Rust?" प्रश्न देखा होगा — इसे हज़ारों बार देखा गया है। और यह कोई संयोग नहीं है।

Rust में सॉर्टिंग उन विषयों में से एक है जहाँ "बस sort() कॉल करना" काम नहीं कर सकता यदि आप कुछ बारीकियाँ नहीं जानते हैं। इस लेख में, हम वेक्टर को सॉर्ट करने के सभी लोकप्रिय तरीकों को समझेंगे: बुनियादी sort() विधि से लेकर कस्टम कम्पेरेटर और स्थिर और अस्थिर सॉर्टिंग के बीच चयन तक। आप सीखेंगे कि Rust में वेक्टर को सही, तेज़ और बिना घबराहट के कैसे सॉर्ट किया जाए।

बुनियादी विधि: sort() — जब सब कुछ सरल हो

वेक्टर को सॉर्ट करने का सबसे सरल तरीका sort() विधि का उपयोग करना है। यह उन प्रकारों के लिए काम करता है जो Ord ट्रेट को लागू करते हैं — और ये सभी मानक प्रिमिटिव (संख्या, स्ट्रिंग, कैरेक्टर) हैं।

fn main() {\n    let mut numbers = vec![4, 2, 9, 1, 5, 6];\n    numbers.sort();\n    println!("{:?}", numbers); // आउटपुट: [1, 2, 4, 5, 6, 9]\n}

ध्यान दें: वेरिएबल numbers को mut (mutable) घोषित किया गया है। sort() विधि वेक्टर को उसी स्थान पर बदलती है, इसलिए mut के बिना कोड संकलित नहीं होगा। यह शुरुआती लोगों की एक सामान्य गलती है — परिवर्तनशीलता के बारे में भूल जाना।

यही बात स्ट्रिंग के लिए भी काम करती है:

fn main() {\n    let mut fruits = vec!["banana", "apple", "cherry", "date"];\n    fruits.sort();\n    println!("{:?}", fruits); // आउटपुट: ["apple", "banana", "cherry", "date"]\n}

डिफ़ॉल्ट रूप से स्ट्रिंग सॉर्टिंग लेक्सिकोग्राफिकल (वर्णमाला क्रम) होती है। यदि आपको लंबाई के अनुसार या केस को अनदेखा करके सॉर्ट करने की आवश्यकता है — तो कस्टम कम्पेरेटर वाला अनुभाग पढ़ें।

sort_unstable(): जब गति क्रम से अधिक महत्वपूर्ण हो

Rust में सॉर्टिंग के दो प्रकार हैं: sort() (स्थिर) और sort_unstable() (अस्थिर)। अंतर यह है कि स्थिर सॉर्टिंग समान तत्वों के सापेक्ष क्रम को बनाए रखती है, जबकि अस्थिर नहीं रखती। यह अकादमिक लगता है, लेकिन व्यवहार में यह महत्वपूर्ण है यदि आप जटिल संरचनाओं को सॉर्ट कर रहे हैं और समान कुंजियों के लिए सम्मिलन क्रम को बनाए रखना चाहते हैं।

हालाँकि, sort_unstable() का एक लाभ है: यह तेज़ काम करता है और कम मेमोरी का उपयोग करता है। बड़े वेक्टर (लाखों तत्व) के लिए, अंतर महत्वपूर्ण हो सकता है।

fn main() {\n    let mut scores = vec![85, 92, 85, 70, 92, 60];\n    scores.sort_unstable();\n    println!("{:?}", scores); // आउटपुट: [60, 70, 85, 85, 92, 92]\n    // दो 85 और दो 92 का क्रम मूल से भिन्न हो सकता है\n}

sort_unstable कब चुनें? यदि आपको समान तत्वों के क्रम की परवाह नहीं है और आप प्रदर्शन के लिए प्रयासरत हैं। यदि पूर्वानुमानितता महत्वपूर्ण है (उदाहरण के लिए, कई कॉलम वाली तालिका को सॉर्ट करना), तो sort() का उपयोग करें।

sort_by(): कस्टम कम्पेरेटर

यदि वेक्टर को गैर-मानक नियम के अनुसार सॉर्ट करने की आवश्यकता हो तो क्या करें? उदाहरण के लिए, संख्याओं को अवरोही क्रम में, स्ट्रिंग को लंबाई के अनुसार, या उपयोगकर्ता-परिभाषित संरचनाओं को किसी एक फ़ील्ड के अनुसार। इसके लिए sort_by() विधि मौजूद है, जो एक क्लोजर-कम्पेरेटर लेती है।

कम्पेरेटर को Ordering लौटाना चाहिए — विकल्पों में से एक: Less, Equal या Greater। ऐसा परिणाम प्राप्त करने का सबसे सरल तरीका .cmp() या .partial_cmp() विधियों का उपयोग करना है।

उदाहरण: संख्याओं को अवरोही क्रम में सॉर्ट करना।

fn main() {\n    let mut numbers = vec![4, 2, 9, 1, 5];\n    numbers.sort_by(|a, b| b.cmp(a));\n    println!("{:?}", numbers); // आउटपुट: [9, 5, 4, 2, 1]\n}

ध्यान दें: हम a और b को बदल रहे हैं —