Rust में एल्गोरिदम और डेटा संरचनाएँ: एक व्यावहारिक मार्गदर्शिका

परिचय: एल्गोरिदम के लिए Rust क्यों?

Rust एक आधुनिक सिस्टम प्रोग्रामिंग भाषा है जो C/C++ के उच्च प्रदर्शन को मेमोरी सुरक्षा के साथ जोड़ती है। एल्गोरिदम और डेटा संरचनाओं को सीखने के लिए Rust विशेष रूप से अच्छा है, क्योंकि:

• स्वामित्व नियंत्रण (ownership) मेमोरी के साथ काम करने के बारे में स्पष्ट रूप से सोचने के लिए बाध्य करता है
• सुरक्षा — कंपाइलर रनटाइम की कई त्रुटियों की अनुमति नहीं देता
• गति — Rust मशीन कोड में कंपाइल होता है, जो प्रदर्शनकारी एल्गोरिदम के लिए महत्वपूर्ण है

इस लेख में, हम व्यावहारिक कोड उदाहरणों के साथ Rust में चार बुनियादी संरचनाओं और एल्गोरिदम के कार्यान्वयन पर चर्चा करेंगे।

1. लिंक्ड लिस्ट (Linked List)

एक क्लासिक डेटा संरचना। Rust में, इसके कार्यान्वयन के लिए हीप में मेमोरी आवंटित करने के लिए Box और नोड की अनुपस्थिति को दर्शाने के लिए Option के उपयोग की आवश्यकता होती है।

सिंगली लिंक्ड लिस्ट का कार्यान्वयन

// लिस्ट के नोड को परिभाषित करें#[derive(Debug)]struct Node<T> {    value: T,    next: Option<Box<Node<T>>>,}

// लिस्ट ही#[derive(Debug)]struct LinkedList<T> {    head: Option<Box<Node<T>>>,}

impl<T> LinkedList<T> {    // खाली लिस्ट बनाएँ    fn new() -> Self {        LinkedList { head: None }    }

    // शुरुआत में तत्व जोड़ें    fn push_front(&mut self, value: T) {        let new_node = Box::new(Node {            value,            next: self.head.take(),        });        self.head = Some(new_node);    }

    // शुरुआत से तत्व हटाएँ    fn pop_front(&mut self) -> Option<T> {        self.head.take().map(|node| {            self.head = node.next;            node.value        })    }}

fn main() {    let mut list = LinkedList::new();    list.push_front(10);    list.push_front(20);    list.push_front(30);    println!("{:?}", list); // LinkedList { head: Some(Node { value: 30, next: ... }) }        let popped = list.pop_front();    println!("हटाया गया: {:?}", popped); // हटाया गया: Some(30)    println!("अब लिस्ट: {:?}", list);}

यहाँ क्या हो रहा है:

• Box<Node> — हीप में नोड की ओर पॉइंटर
• Option — या तो नोड है (Some) या नहीं (None)
• take() — Option से मान लेता है, None छोड़ता है

2. बाइनरी सर्च ट्री (Binary Search Tree)

ट्री एक पदानुक्रमिक संरचना है। बाइनरी सर्च ट्री में, प्रत्येक नोड में एक बायाँ और दायाँ चाइल्ड होता है, जिसमें बायाँ रूट से छोटा और दायाँ रूट से बड़ा होता है।

BST का कार्यान्वयन

use std::cmp::Ordering;

#[derive(Debug)]struct TreeNode<T> {    value: T,    left: Option<Box<TreeNode<T>>>,    right: Option<Box<TreeNode<T>>>,}

#[derive(Debug)]struct BinarySearchTree<T> {    root: Option<Box<TreeNode<T>>>,}

impl<T: Ord> BinarySearchTree<T> {    fn new() -> Self {        BinarySearchTree { root: None }    }

    // तत्व सम्मिलित करना    fn insert(&mut self, value: T) {        let mut current = &mut self.root;        while let Some(node) = current {            match value.cmp(&node.value) {                Ordering::Less => current = &mut node.left,                Ordering::Greater => current = &mut node.right,                Ordering::Equal => return, // डुप्लिकेट को अनदेखा करें            }        }        *current = Some(Box::new(TreeNode {            value,            left: None,            right: None,        }));    }

    // तत्व खोजना    fn contains(&self, value: &T) -> bool {        let mut current = &self.root;        while let