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

रस्ट में एल्गोरिदम और डेटा संरचनाओं का परिचय

प्रोग्रामिंग भाषा Rust ने अपने उच्च प्रदर्शन और मेमोरी सुरक्षा की सख्त गारंटी के कारण डेवलपर्स की मान्यता प्राप्त की है। हालांकि, Python या JavaScript जैसी अन्य भाषाओं से Rust में संक्रमण, विशेष रूप से क्लासिक एल्गोरिदम और डेटा संरचनाओं को लागू करते समय, कठिन हो सकता है। इस लेख में, हम देखेंगे कि स्वामित्व (ownership) और उधार (borrowing) प्रणाली की विशेषताओं को ध्यान में रखते हुए, Rust में बुनियादी डेटा संरचनाओं और एल्गोरिदम को प्रभावी ढंग से कैसे लागू किया जाए।

यह लेख उन डेवलपर्स के लिए है जो पहले से Rust की मूल बातों से परिचित हैं। हम व्यावहारिक कोड उदाहरणों पर ध्यान केंद्रित करेंगे जिनका उपयोग वास्तविक परियोजनाओं में तुरंत किया जा सकता है। सभी उदाहरण विस्तृत टिप्पणियों के साथ होंगे।

Rust में लिंक्ड लिस्ट का कार्यान्वयन

लिंक्ड लिस्ट मौलिक डेटा संरचनाओं में से एक है। Rust में, स्वामित्व के नियमों के कारण इसके कार्यान्वयन पर विशेष ध्यान देने की आवश्यकता है। आइए मेमोरी प्रबंधन के लिए Box का उपयोग करके एक सिंगली लिंक्ड लिस्ट पर विचार करें।

बुनियादी सिंगली लिंक्ड लिस्ट

आइए नोड और लिस्ट की परिभाषा से शुरू करें:

use std::fmt::Display;

#[derive(Debug)]struct Node<T> {    value: T,    next: Option<Box<Node<T>>>,}

#[derive(Debug)]struct LinkedList<T> {    head: Option<Box<Node<T>>>,    length: usize,}

impl<T> LinkedList<T> {    fn new() -> Self {        LinkedList {            head: None,            length: 0,        }    }

    fn push_front(&mut self, value: T) {        let new_node = Box::new(Node {            value,            next: self.head.take(),        });        self.head = Some(new_node);        self.length += 1;    }

    fn pop_front(&mut self) -> Option<T> {        self.head.take().map(|node| {            self.head = node.next;            self.length -= 1;            node.value        })    }

    fn is_empty(&self) -> bool {        self.head.is_none()    }

    fn len(&self) -> usize {        self.length    }}

Option<Box<Node<T>>> के उपयोग पर ध्यान दें। Rust में रिकर्सिव संरचनाएं बनाने का यह मानक तरीका है, क्योंकि कंपाइलर को पहले से ज्ञात आकार की आवश्यकता होती है। take() विधि Option से मान को सुरक्षित रूप से निकालने की अनुमति देती है, इसे None से बदल देती है।

लिस्ट पर इटरेशन

लिस्ट के लिए इटरेटर लागू करें:

impl<T: Clone> LinkedList<T> {    fn iter(&self) -> LinkedListIterator<T> {        LinkedListIterator {            current: self.head.as_deref(),        }    }}

struct LinkedListIterator<T> {    current: Option<&Node<T>>,}

impl<T> Iterator for LinkedListIterator<T> {    type Item = &T;

    fn next(&mut self) -> Option<Self::Item> {        self.current.take().map(|node| {            self.current = node.next.as_deref();            &node.value        })    }}

Rust में बाइनरी सर्च ट्री (BST)

पेड़ एक और महत्वपूर्ण संरचना है। आइए इंसर्शन, सर्च और ट्रैवर्सल के समर्थन के साथ एक बाइनरी सर्च ट्री लागू करें।

संरचना और बुनियादी इंसर्शन

#[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 {            if value <
```