Rust में एल्गोरिदम और डेटा संरचनाएँ: शुरुआती लोगों के लिए गाइड

Rust में एल्गोरिदम और डेटा संरचनाएँ: शुरुआती लोगों के लिए पूर्ण गाइड

Rust एक प्रोग्रामिंग भाषा है जो C/C++ की उच्च प्रदर्शन क्षमता को कंपाइलेशन चरण पर गारंटीकृत मेमोरी सुरक्षा के साथ जोड़ती है। शुरुआती डेवलपर्स के लिए, Rust में एल्गोरिदम और डेटा संरचनाओं का अध्ययन न केवल कंप्यूटर साइंस की मूलभूत अवधारणाओं में महारत हासिल करने का एक तरीका है, बल्कि भाषा की अनूठी विशेषताओं को समझने का अवसर भी है: स्वामित्व (ownership), उधार (borrowing) और जीवनकाल (lifetimes)।

इस लेख में, हम प्रमुख डेटा संरचनाओं और एल्गोरिदम पर चर्चा करेंगे जो प्रत्येक डेवलपर को जानना चाहिए। सभी कोड उदाहरण Rust में लिखे गए हैं और चलाने के लिए तैयार हैं। हम मानक लाइब्रेरी द्वारा प्रदान की गई बुनियादी संरचनाओं से शुरू करेंगे, फिर क्लासिक एल्गोरिदम के कार्यान्वयन की ओर बढ़ेंगे।

1. Rust में बुनियादी डेटा संरचनाएँ

Rust की मानक लाइब्रेरी (std) तैयार डेटा संरचनाओं का एक समृद्ध सेट प्रदान करती है। आइए उनमें से तीन सबसे महत्वपूर्ण पर विचार करें।

वेक्टर (Vec)

Vec एक डायनामिक ऐरे है जो अपना आकार बदल सकता है। यह Java में ArrayList या Python में list के समान है। वेक्टर मेमोरी में तत्वों की सतत व्यवस्था सुनिश्चित करते हैं, जिससे इंडेक्स द्वारा एक्सेस बहुत तेज़ (O(1)) हो जाता है।

fn main() {\n    // खाली वेक्टर बनाना\n    let mut numbers: Vec<i32> = Vec::new();\n    \n    // तत्व जोड़ना\n    numbers.push(10);\n    numbers.push(20);\n    numbers.push(30);\n    \n    // इंडेक्स द्वारा एक्सेस\n    let first = numbers[0]; // 10\n    \n    // इटरेशन\n    for num in &numbers {\n        println!("{}", num);\n    }\n    \n    // vec! मैक्रो\n    let fruits = vec!["apple", "banana", "cherry"];\n    println!("दूसरा फल: {}", fruits[1]); // banana\n}

हैश मैप (HashMap)

HashMap एक डेटा संरचना है जो की-वैल्यू जोड़े संग्रहीत करती है। यह इन्सर्शन, सर्च और डिलीट के लिए औसत एक्सेस समय O(1) प्रदान करती है। यह उन कार्यों के लिए आदर्श है जहाँ की द्वारा डेटा को जल्दी से खोजने की आवश्यकता होती है।

use std::collections::HashMap;\n\nfn main() {\n    let mut scores = HashMap::new();\n    \n    scores.insert(String::from("Alice"), 100);\n    scores.insert(String::from("Bob"), 85);\n    \n    // की द्वारा मान प्राप्त करना\n    let alice_score = scores.get(&String::from("Alice"));\n    match alice_score {\n        Some(score) => println!("Alice ने स्कोर किया: {}", score),\n        None => println!("Alice नहीं मिली"),\n    }\n    \n    // सभी जोड़ों पर लूप\n    for (name, score) in &scores {\n        println!("{}: {}", name, score);\n    }\n}

स्ट्रिंग (String)

Rust में दो मुख्य प्रकार की स्ट्रिंग हैं: &str (स्ट्रिंग स्लाइस) और String (परिवर्तनीय, स्वामित्व वाली स्ट्रिंग)। UTF-8 एन्कोडिंग के कारण Rust में स्ट्रिंग के साथ काम करने में सावधानी की आवश्यकता होती है।

fn main() {\n    let mut hello = String::from("नमस्ते, ");\n    hello.push_str("दुनिया!"); // स्ट्रिंग जोड़ना\n    hello.push('!'); // कैरेक्टर जोड़ना\n    \n    println!("{}", hello); // नमस्ते, दुनिया!!\n    \n    // स्ट्रिंग स्लाइस (कैरेक्टर सीमाओं से सावधान!)\n    let slice = &hello[0..18]; // "नमस्ते, दुनिया"\n    println!("स्लाइस: {}", slice);\n}

2. स्टैक और क्यू का कार्यान्वयन

स्टैक और क्यू मूलभूत डेटा संरचनाएँ हैं जिनका उपयोग अक्सर एल्गोरिदम में किया जाता है। Rust में, इन्हें Vec का उपयोग करके आसानी से लागू किया जा सकता है।

स्टैक (LIFO — लास्ट इन, फर्स्ट आउट)

स्टैक "सबसे बाद में आने वाला, सबसे पहले बाहर" के सिद्धांत पर काम करता है। Vec पहले से ही push और pop विधियाँ प्रदान करता है, जो स्टैक के व्यवहार को लागू करती हैं।

fn main() {\n    let mut stack: Vec<i32> = Vec::new();\n    \n    stack.push(1);\n    stack.push(2);\n    stack.push(3);\n    \n    while let Some(top) = stack.pop() {\n        println!("निकाल रहे हैं: {}", top);\n    }\n    // आउटपुट: 3, 2, 1\n}

क्यू (FIFO — फर्स्ट इन, फर्स्ट आउट