मैंने सूची और स्टैक जैसी डेटा संरचनाओं का वर्णन करने के लिए उपयोग किया जाने वाला घुसपैठ शब्द देखा है , लेकिन इसका क्या मतलब है?
क्या आप एक घुसपैठ डेटा संरचना का एक कोड उदाहरण दे सकते हैं, और यह कैसे गैर-घुसपैठ से अलग होता है?
इसके अलावा, इसे घुसपैठ (या गैर-घुसपैठ) क्यों बनाते हैं? क्या लाभ हैं? नुकसान क्या हैं?
जवाबों:
एक घुसपैठ डेटा संरचना वह है जिसे उन तत्वों से सहायता की आवश्यकता होती है जो उन्हें संग्रहीत करने के लिए संग्रहीत करना चाहते हैं।
मुझे वह reword करने दो। जब आप उस डेटा संरचना में कुछ डालते हैं, तो यह "कुछ" इस तथ्य से अवगत हो जाता है कि यह उस डेटा संरचना में है, किसी तरह से। तत्व को डेटा संरचना में जोड़ने से तत्व बदल जाता है।
उदाहरण के लिए, आप एक गैर-घुसपैठ बाइनरी ट्री का निर्माण कर सकते हैं, जहां प्रत्येक नोड में बाएं और दाएं उप-पेड़ों का संदर्भ होता है, और उस नोड के तत्व मूल्य का संदर्भ होता है।
या, आप एक घुसपैठ बना सकते हैं जहां उन उप-पेड़ों के संदर्भ स्वयं मूल्य में एम्बेडेड होते हैं।
एक घुसपैठ डेटा संरचना का एक उदाहरण उन तत्वों की एक क्रमबद्ध सूची होगी जो परस्पर परिवर्तनशील हैं। यदि तत्व बदलता है, तो सूची को फिर से व्यवस्थित करने की आवश्यकता होती है, इसलिए सूची वस्तु को अपना सहयोग प्राप्त करने के लिए तत्वों की गोपनीयता पर ध्यान देना पड़ता है। अर्थात। तत्व को उस सूची के बारे में जानना होगा जो उसमें है और परिवर्तनों के बारे में उसे सूचित करता है।
ORM- सिस्टम आम तौर पर घुसपैठ डेटा संरचनाओं के चारों ओर घूमते हैं, वस्तुओं की बड़ी सूची पर पुनरावृत्ति को कम करने के लिए। उदाहरण के लिए, यदि आप डेटाबेस में सभी कर्मचारियों की सूची प्राप्त करते हैं, तो उनमें से किसी एक का नाम बदलें, और इसे डेटाबेस में वापस सहेजना चाहते हैं, कर्मचारियों की घुसपैठ सूची को तब बताया जाएगा जब कर्मचारी ऑब्जेक्ट बदल गया हो क्योंकि ऑब्जेक्ट जानता है कि यह किस सूची में है।
एक गैर-दखल देने वाली सूची नहीं बताई जाएगी, और यह पता लगाना होगा कि क्या बदल गया और कैसे यह अपने आप बदल गया।
एक घुसपैठ कंटेनर में डेटा कंटेनर के लिए आवश्यक जानकारी संग्रहीत करने के लिए स्वयं जिम्मेदार है। इसका मतलब यह है कि एक तरफ डेटा प्रकार को विशेष करने की आवश्यकता है, यह इस बात पर निर्भर करता है कि इसे कैसे संग्रहीत किया जाएगा, दूसरी तरफ इसका मतलब है कि डेटा "जानता है" कि यह कैसे संग्रहीत किया जाता है और इस तरह इसे थोड़ा बेहतर तरीके से अनुकूलित किया जा सकता है।
गैर दखल:
template<typename T>
class LinkedList
{
struct ListItem
{
T Value;
ListItem* Prev;
ListItem* Next;
};
ListItem* FirstItem;
ListItem* LastItem;
[...]
ListItem* append(T&& val)
{
LastItem = LastItem.Next = new ListItem{val, LastItem, nullptr};
};
};
LinkedList<int> IntList;
दखल:
template<typename T>
class LinkedList
{
T* FirstItem;
T* LastItem;
[...]
T* append(T&& val)
{
T* newValue = new T(val);
newValue.Next = nullptr;
newValue.Prev = LastItem;
LastItem.Next = newValue;
LastItem = newValue;
};
};
struct IntListItem
{
int Value;
IntListItem* Prev;
IntListItem* Next;
};
LinkedList<IntListItem> IntList;
व्यक्तिगत रूप से मैं पारदर्शिता के लिए घुसपैठ डिजाइन पसंद करता हूं।