पायथन से जुड़ी सूची: बक्से में बिल्लियाँ

फिर से नमस्कार! पायथन डेवलपर कोर्स की शुरुआत की प्रत्याशा में , हमने आपके लिए पायथन में लिंक की गई सूचियों पर एक छोटी आधिकारिक सामग्री तैयार की है।

पायथन एक बहुत ही सुविधाजनक और बहुआयामी भाषा है, लेकिन डिफ़ॉल्ट रूप से इसमें लिंक की गई सूची या लिंक्डलिस्ट के रूप में ऐसी डेटा संरचना नहीं है। आज मैं इस विषय पर अपनी सर्वोत्तम प्रथाओं को साझा करूंगा और इस डेटा संरचना के बारे में थोड़ी बात करूंगा। यह लेख उन लोगों के लिए दिलचस्पी का होगा जो पहले लिंक्ड सूचियों के विषय में आते हैं और यह समझना चाहते हैं कि वे एक एल्गोरिथम दृष्टिकोण से कैसे काम करते हैं।

---

लिंक्डलिस्ट क्या है?

एक लिंक्डलिस्ट या लिंक की गई सूची एक डेटा संरचना है। एक लिंक की गई सूची किसी भी तत्व से एक द्विदिश कतार बनाने की क्षमता प्रदान करती है। ऐसी सूची के प्रत्येक तत्व को एक नोड माना जाता है। वास्तव में, एक नोड का मूल्य होता है, साथ ही पिछले और बाद के नोड्स के दो लिंक। यही है, सूची नोड्स द्वारा "लिंक्ड" है जो सूची को ऊपर या नीचे ले जाने में मदद करती है। इन संरचनात्मक विशेषताओं के कारण, आप लिंक की गई सूची से एक स्टैक, कतार या डबल कतार को व्यवस्थित कर सकते हैं।

आइए सूखी परिभाषाओं की कल्पना करें। अब हमारे पास बिल्लियाँ हैं जो बक्सों में बैठी हैं। और प्रत्येक बॉक्स पर यह कहता है कि यह क्रम में क्या है और इसके लिए क्या होना चाहिए।



हम एक लिंक्ड सूची के साथ क्या करेंगे:

1. जांचें कि क्या यह या वह तत्व इसमें निहित है;
2. अंत में नोड्स जोड़ें;
3. सूचकांक द्वारा एक नोड का मूल्य प्राप्त करें;
4. नोड्स हटाएं।

वास्तव में, उनके साथ काम करने के लिए बहुत अधिक विकल्प हैं, लेकिन हम इन बुनियादी चरणों के कार्यान्वयन पर ध्यान देंगे। वे किस सिद्धांत से बने हैं, यह समझने के बाद, आप स्वयं आसानी से अपने तरीकों को लागू कर सकते हैं।

आपको दो कक्षाएं बनाकर शुरू करना होगा:

class Box: def __init__ (self,cat = None): self.cat = cat self.nextcat = None class LinkedList: def __init__(self): self.head = None 

सामान्य स्थिति में, हमारे पास एक नोड होता है जिसके अंदर कुछ मूल्य होता है - एक बिल्ली, और अगले नोड के लिए एक लिंक। अर्थात्, बॉक्स क्लास में, क्रमशः एक बिल्ली है और अगले बॉक्स के लिए एक लिंक है। किसी भी सूची की तरह, सुसंगत भी एक शुरुआत है, अर्थात् सिर। चूंकि शुरू में वहां कुछ भी नहीं है, इसलिए शुरुआती तत्व कोई भी नहीं है।

सूची में आइटम है

चलो एक साधारण से शुरू करते हैं। यह देखने के लिए कि क्या श्रृंखला में स्थित किसी एक बॉक्स में कोई विशेष बिल्ली है, आपको सूची में तत्व के मूल्यों के साथ मौजूदा मूल्य की जांच करते हुए, पूरी सूची के माध्यम से चक्र करने की आवश्यकता है।

 def contains (self, cat): lastbox = self.head while (lastbox): if cat == lastbox.cat: return True else: lastbox = lastbox.nextcat return False 

सूची के अंत में नोड जोड़ें

पहले आपको एक नया बॉक्स बनाने की आवश्यकता है, और पहले से ही इसमें एक नई बिल्ली डालनी है। उसके बाद, आपको लिंक किए गए सूची की शुरुआत से जांचना होगा, यदि वर्तमान नोड में अगले एक के लिए लिंक है और यदि कोई है, तो उसके पास जाएं, अन्यथा नोड अंतिम है, इसलिए आपको अगले नोड के लिए एक लिंक बनाने और उसी नए बॉक्स को इसमें डालने की आवश्यकता है। जो हमने बनाया।

  def addToEnd(self, newcat): newbox = Box(newcat) if self.head is None: self.head = newbox return lastbox = self.head while (lastbox.nextcat): lastbox = lastbox.nextcat lastbox.nextcat = newbox 

अनुक्रमणिका द्वारा एक नोड प्राप्त करें

इंडेक्स कैटइंडेक्स द्वारा हम एक बॉक्स नोड प्राप्त करना चाहते हैं, लेकिन चूंकि इंडेक्स नोड्स के लिए प्रदान नहीं किया गया है, इसलिए हमें किसी प्रकार के प्रतिस्थापन के साथ आने की आवश्यकता है, अर्थात् एक चर जो इंडेक्स के रूप में कार्य करेगा। यह वैरिएबल BoxIndex है। हम पूरी सूची से गुजरते हैं और नोड के "सीरियल नंबर" की जांच करते हैं, और यदि यह वांछित सूचकांक से मेल खाता है, तो हम परिणाम का उत्पादन करते हैं।

  def get(self, catIndex): lastbox = self.head boxIndex = 0 while boxIndex <= catIndex: if boxIndex == catIndex: return lastbox.cat boxIndex = boxIndex + 1 lastbox = lastbox.nextcat 

नोड हटाएँ

यहां हम कम से कम कुछ विविधता को पेश करने के लिए सूचकांक द्वारा नहीं बल्कि मूल्य द्वारा एक तत्व को हटाने पर विचार करते हैं।

खोज सूची के प्रमुख से शुरू होती है, जो कि एक पंक्ति में पहले बॉक्स से होती है, और तब तक जारी रहती है जब तक बक्से बाहर नहीं निकल जाते हैं, जब तक कि हेडकैट कोई नहीं बन जाता है। हम जाँचते हैं कि क्या मौजूदा नोड में संग्रहीत मूल्य उस मिलान से मेल खाता है जिसे हम हटाना चाहते हैं। यदि नहीं, तो हम अभी आगे बढ़ते हैं। हालाँकि, अगर यह मेल खाता है, तो हम इसे हटा देते हैं और लिंक को फिर से लिंक करते हैं, अर्थात्, हम N-th बॉक्स को हटा देते हैं, जबकि N-1 बॉक्स अब N + 1 बॉक्स को संदर्भित करता है।

  def removeBox(self,rmcat): headcat = self.head if headcat is not None: if headcat.cat==rmcat: self.head = headcat.nextcat headcat = None return while headcat is not None: if headcat.cat==rmcat: break lastcat = headcat headcat = headcat.nextcat if headcat == None: return lastcat.nextcat = headcat.nextcat headcat = None 

यह सब, सामग्री को पढ़ने के लिए धन्यवाद! वास्तव में, लिंक्डलिस्ट संरचना जटिल नहीं है, और यह समझना महत्वपूर्ण है कि यह अंदर से कैसे काम करता है। बेशक, पाइथन में इसे लंबोदर भावों में लागू किया जा सकता था, इसने बहुत कम जगह ली होगी, लेकिन यहाँ मैंने इसका ढाँचा समझाने का लक्ष्य रखा है, और पाइथन में इसके संचालन के सिद्धांत को अनुकूलन का पीछा करने के बजाए यथासंभव विस्तृत किया गया है।

स्रोत कोड यहां पाया जा सकता है ।