पायथन में लिंक्ड सूचियाँ

परिचय

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

लिंक्ड सूचियों के फायदे और नुकसान

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

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

पायथन में लिंक्ड सूचियाँ लागू करना

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

एकल रूप से लिंक की गई सूची

सिंगल लिंक्ड लिस्ट में नोड्स होते हैं जहां प्रत्येक नोड में एक मान और अनुक्रम में अगले नोड का संदर्भ होता है। यहां बताया गया है कि आप पायथन में सिंगल लिंक्ड लिस्ट कैसे बना सकते हैं:

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

class Linked List:
    def __init__(self):
        self.head = None

एकल लिंक्ड सूची बनाना

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

एकल लिंक्ड सूची में नोड्स सम्मिलित करना

सिंगल लिंक्ड सूची में नोड्स डालने में पड़ोसी नोड्स के संदर्भों को अद्यतन करना शामिल है। यहां सूची की शुरुआत में नोड डालने का एक उदाहरण दिया गया है:

def insert_at_beginning(self, value):
    new_node = Node(value)
    new_node.next = self.head
    self.head = new_node

एकल लिंक्ड सूची से नोड्स हटाना

एकल लिंक्ड सूची से नोड्स को हटाने के लिए पड़ोसी नोड्स के संदर्भों को अद्यतन करने की आवश्यकता होती है। यहां एक विशिष्ट मान वाले नोड को हटाने का एक उदाहरण दिया गया है:

def delete_node(self, value):
    current = self.head
    if current.value == value:
        self.head = current.next
    else:
        while current.next:
            if current.next.value == value:
                current.next = current.next.next
                break
            current = current.next

एकल लिंक्ड सूची में खोजना

सिंगल लिंक्ड सूची में किसी विशिष्ट मान की खोज में तब तक सूची को पार करना शामिल होता है जब तक कि मान न मिल जाए या सूची के अंत तक न पहुंच जाए। यहां किसी मान की खोज का एक उदाहरण दिया गया है:

def search(self, value):
    current = self.head
    while current:
        if current.value == value:
            return True
        current = current.next
    return False

एकल लिंक्ड सूची को उलटना

एकल लिंक्ड सूची को उलटने के लिए पिछले नोड को इंगित करने के लिए प्रत्येक नोड के संदर्भों को अद्यतन करने की आवश्यकता होती है। यहां एकल लिंक्ड सूची को उलटने का एक उदाहरण दिया गया है:

def reverse(self):
    previous = None
    current = self.head
    while current:
        next_node = current.next
        current.next = previous
        previous = current
        current = next_node
    self.head = previous

डबल लिंक्ड लिस्ट

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

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None
        self.previous = None

class DoublyLinked List:
    def __init__(self):
        self.head = None

दोहरी लिंक्ड सूची बनाना

एक डबल लिंक्ड सूची बनाने के लिए, हम एक नोड वर्ग को परिभाषित करते हैं जिसमें एक मान, अगले नोड का संदर्भ और पिछले नोड का संदर्भ होता है। DoublyLinked List वर्ग नोड्स के लिए कंटेनर के रूप में कार्य करता है, जिसमें हेड विशेषता सूची में पहले नोड की ओर इशारा करती है।

दोहरी लिंक्ड सूची में नोड्स सम्मिलित करना

डबल लिंक्ड सूची में नोड्स डालने में पड़ोसी नोड्स के संदर्भों को अद्यतन करना शामिल है। यहां सूची की शुरुआत में नोड डालने का एक उदाहरण दिया गया है:

def insert_at_beginning(self, value):
    new_node = Node(value)
    if self.head:
        self.head.previous = new_node
    new_node.next = self.head
    self.head = new_node

दोहरी लिंक वाली सूची से नोड्स हटाना

डबली लिंक्ड सूची से नोड्स को हटाने के लिए पड़ोसी नोड्स के संदर्भों को अद्यतन करने की आवश्यकता होती है। यहां एक विशिष्ट मान वाले नोड को हटाने का एक उदाहरण दिया गया है:

def delete_node(self, value):
    current = self.head
    if current.value == value:
        self.head = current.next
        if self.head:
            self.head.previous = None
    else:
        while current.next:
            if current.next.value == value:
                current.next = current.next.next
                if current.next:
                    current.next.previous = current
                break
            current = current.next

दोहरी लिंक्ड सूची में खोज रहे हैं

डबली लिंक्ड सूची में किसी विशिष्ट मान की खोज करने में सूची को किसी भी दिशा में तब तक पार करना शामिल होता है जब तक कि मान नहीं मिल जाता है या सूची के अंत तक नहीं पहुंच जाता है। यहां किसी मान की खोज का एक उदाहरण दिया गया है:

def search(self, value):
    current = self.head
    while current:
        if current.value == value:
            return True
        current = current.next
    return False

दोहरी लिंक्ड सूची को उलटना

डबल लिंक्ड सूची को उलटने के लिए अगले और पिछले पॉइंटर्स को स्वैप करने के लिए प्रत्येक नोड के संदर्भों को अपडेट करने की आवश्यकता होती है। यहां दोहरी लिंक्ड सूची को उलटने का एक उदाहरण दिया गया है:

def reverse(self):
    current = self.head
    while current:
        next_node = current.next
        current.next = current.previous
        current.previous = next_node
        if not next_node:
            self.head = current
        current = next_node

सर्कुलर लिंक्ड लिस्ट

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

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

class CircularLinked List:
    def __init__(self):
        self.head = None

एक परिपत्र लिंक्ड सूची बनाना

एक सर्कुलर लिंक्ड लिस्ट बनाने के लिए, हम एक नोड क्लास को परिभाषित करते हैं जिसमें एक मान और अगले नोड का संदर्भ होता है। सर्कुलरलिंक्ड सूची वर्ग नोड्स के लिए कंटेनर के रूप में कार्य करता है, जिसमें हेड विशेषता सूची में पहले नोड की ओर इशारा करती है। इसके अतिरिक्त, अंतिम नोड का अगला संदर्भ एक गोलाकार संरचना बनाते हुए, सिर पर सेट किया जाता है।

एक परिपत्र लिंक्ड सूची में नोड्स सम्मिलित करना

एक सर्कुलर लिंक्ड सूची में नोड्स डालने में पड़ोसी नोड्स के संदर्भों को अद्यतन करना शामिल है। यहां सूची की शुरुआत में नोड डालने का एक उदाहरण दिया गया है:

def insert_at_beginning(self, value):
    new_node = Node(value)
    if not self.head:
        self.head = new_node
        new_node.next = self.head
    else:
        current = self.head
        while current.next != self.head:
            current = current.next
        current.next = new_node
        new_node.next = self.head
        self.head = new_node

एक परिपत्र लिंक्ड सूची से नोड्स हटाना

सर्कुलर लिंक्ड सूची से नोड्स को हटाने के लिए पड़ोसी नोड्स के संदर्भों को अद्यतन करने की आवश्यकता होती है। यहां एक विशिष्ट मान वाले नोड को हटाने का एक उदाहरण दिया गया है:

def delete_node(self, value):
    if not self.head:
        return
    current = self.head
    if current.value == value:
        while current.next != self.head:
            current = current.next
        if current == self.head:
            self.head = None
        else:
            current.next = self.head.next
            self.head = self.head.next
    else:
        previous = None
        while current.next != self.head:
            previous = current
            current = current.next
            if current.value == value:
                previous.next = current.next
                break

एक परिपत्र लिंक्ड सूची में खोज रहे हैं

एक सर्कुलर लिंक्ड सूची में एक विशिष्ट मान की खोज करने में सूची को तब तक ट्रेस करना शामिल होता है जब तक कि मान नहीं मिल जाता है या पूरी सूची ट्रैवर्स नहीं हो जाती है। यहां किसी मान की खोज का एक उदाहरण दिया गया है:

def search(self, value):
    if not self.head:
        return False
    current = self.head
    while True:
        if current.value == value:
            return True
        current = current.next
        if current == self.head:
            break
    return False

एक परिपत्र लिंक्ड सूची को उलटना

एक सर्कुलर लिंक्ड सूची को उलटने के लिए सर्कुलर संरचना को उलटने के लिए प्रत्येक नोड के संदर्भों को अद्यतन करने की आवश्यकता होती है। यहां एक सर्कुलर लिंक्ड सूची को उलटने का एक उदाहरण दिया गया है:

def reverse(self):
    if not self.head:
        return
    previous = None
    current = self.head
    next_node = current.next
    while True:
        current.next = previous
        previous = current
        current = next_node
        next_node = next_node.next
        if current == self.head:
            break
    self.head = previous

लिंक्ड सूचियों पर सामान्य संचालन

लिंक्ड सूचियाँ विभिन्न सामान्य परिचालनों का समर्थन करती हैं जिन्हें तत्वों पर निष्पादित किया जा सकता है। आइए इनमें से कुछ ऑपरेशनों के बारे में जानें:

लिंक्ड सूची में तत्वों तक पहुँचना

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

def get_element(self, index):
    current = self.head
    count = 0
    while current:
        if count == index:
            return current.value
        count += 1
        current = current.next
    raise IndexError("Index out of range")

लिंक्ड सूची में तत्वों को संशोधित करना

लिंक्ड सूची में तत्वों को संशोधित करने में वांछित तत्व को खोजने और उसके मूल्य को अपडेट करने के लिए सूची को पार करना शामिल है। यहां किसी विशिष्ट सूचकांक पर किसी तत्व को संशोधित करने का एक उदाहरण दिया गया है:

def modify_element(self, index, new_value):
    current = self.head
    count = 0
    while current:
        if count == index:
            current.value = new_value
            return
        count += 1
        current = current.next
    raise IndexError("Index out of range")

लिंक की गई सूची की लंबाई ज्ञात करना

लिंक्ड सूची की लंबाई ज्ञात करने के लिए, हम सूची को पार कर सकते हैं और नोड्स की संख्या की गणना कर सकते हैं। यहां लिंक्ड सूची की लंबाई ज्ञात करने का एक उदाहरण दिया गया है:

def get_length(self):
    current = self.head
    count = 0
    while current:
        count += 1
        current = current.next
    return count

जाँच कर रहा है कि लिंक्ड सूची खाली है या नहीं

यह जांचने के लिए कि क्या कोई लिंक्ड सूची खाली है, हम बस यह जांच सकते हैं कि क्या हेड नोड कोई नहीं है। यहां यह जांचने का एक उदाहरण दिया गया है कि लिंक्ड सूची खाली है या नहीं:

def is_empty(self):
    return self.head is None

लिंक्ड सूचियों को संयोजित करना

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

def concatenate(self, other_list):
    if not self.head:
        self.head = other_list.head
    else:
        current = self.head
        while current.next:
            current = current.next
        current.next = other_list.head

लिंक्ड सूची बनाम ऐरे

लिंक्ड सूचियाँ और सरणियाँ दोनों आमतौर पर उपयोग की जाने वाली डेटा संरचनाएं हैं, लेकिन उनकी अलग-अलग विशेषताएं हैं जो उन्हें विभिन्न परिदृश्यों के लिए उपयुक्त बनाती हैं। आइए मेमोरी दक्षता, सम्मिलन और विलोपन दक्षता और यादृच्छिक पहुंच दक्षता के संदर्भ में लिंक्ड सूचियों और सरणियों की तुलना करें।

स्मृति दक्षता

लिंक्ड सूचियाँ सरणियों की तुलना में अधिक मेमोरी-कुशल होती हैं क्योंकि उन्हें सन्निहित मेमोरी आवंटन की आवश्यकता नहीं होती है। लिंक्ड सूची में प्रत्येक नोड को केवल मान और अगले नोड के संदर्भ को संग्रहीत करने की आवश्यकता होती है, जबकि सरणियों को सभी तत्वों के लिए मेमोरी आवंटित करने की आवश्यकता होती है, भले ही उनका उपयोग न किया गया हो।

सम्मिलन और विलोपन दक्षता

लिंक्ड सूचियाँ सम्मिलन और विलोपन संचालन में उत्कृष्टता प्राप्त करती हैं, खासकर जब तत्वों को सूची के बीच से बार-बार जोड़ा या हटाया जाता है। किसी लिंक्ड सूची में किसी तत्व को सम्मिलित करने या हटाने के लिए केवल पड़ोसी नोड्स के संदर्भों को अद्यतन करने की आवश्यकता होती है, जबकि सरणियों को परिवर्तन को समायोजित करने के लिए तत्वों को स्थानांतरित करने की आवश्यकता हो सकती है।

रैंडम एक्सेस दक्षता

ऐरे उनके सूचकांकों के आधार पर तत्वों तक कुशल यादृच्छिक पहुंच प्रदान करते हैं, क्योंकि वे प्रत्यक्ष मेमोरी एड्रेसिंग की अनुमति देते हैं। इसके विपरीत, लिंक्ड सूचियों को किसी विशिष्ट सूचकांक पर किसी तत्व तक पहुंचने के लिए शुरू से ही सूची को पार करने की आवश्यकता होती है, जिसके परिणामस्वरूप यादृच्छिक पहुंच संचालन के लिए प्रदर्शन धीमा हो जाता है।

सही डेटा संरचना का चयन करना

लिंक्ड सूचियों और सरणियों के बीच चयन एप्लिकेशन की विशिष्ट आवश्यकताओं पर निर्भर करता है। यदि बार-बार संशोधन और गतिशील आकार बदलना अपेक्षित है, तो लिंक्ड सूचियाँ एक बेहतर विकल्प है। दूसरी ओर, यदि रैंडम एक्सेस और मेमोरी दक्षता महत्वपूर्ण हैं, तो ऐरे अधिक उपयुक्त हैं।

लिंक्ड सूची अनुप्रयोग

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

आप भी हमारे में नामांकन कर सकते हैं नि: शुल्क पाठ्यक्रम आज!

ढेर और कतारें लागू करना

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

स्टैक एक डेटा संरचना है जो लास्ट-इन-फर्स्ट-आउट (LIFO) सिद्धांत का पालन करती है। तत्वों को एक ही सिरे से जोड़ा और हटाया जाता है, जिसे स्टैक के शीर्ष के रूप में जाना जाता है। लिंक की गई सूचियाँ स्टैक को लागू करने का एक कुशल तरीका प्रदान करती हैं क्योंकि हम सूची के शीर्ष से तत्वों को आसानी से जोड़ या हटा सकते हैं।

यहां पायथन में लिंक की गई सूची का उपयोग करके स्टैक को लागू करने का एक उदाहरण दिया गया है:

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class Stack:
    def __init__(self):
        self.head = None

    def push(self, data):
        new_node = Node(data)
        new_node.next = self.head
        self.head = new_node

    def pop(self):
        if self.head is None:
            return None
        popped = self.head.data
        self.head = self.head.next
        return popped

दूसरी ओर, कतार फ़र्स्ट-इन-फर्स्ट-आउट (फीफो) सिद्धांत का पालन करती है। तत्वों को एक छोर पर जोड़ा जाता है, जिसे पीछे के रूप में जाना जाता है, और दूसरे छोर से हटा दिया जाता है, जिसे सामने के रूप में जाना जाता है। कतारों को कुशलतापूर्वक लागू करने के लिए लिंक की गई सूचियों का भी उपयोग किया जा सकता है।

यहां पायथन में एक लिंक्ड सूची का उपयोग करके कतार को लागू करने का एक उदाहरण दिया गया है:

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class Queue:
    def __init__(self):
        self.front = None
        self.rear = None

    def enqueue(self, data):
        new_node = Node(data)
        if self.rear is None:
            self.front = new_node
            self.rear = new_node
        else:
            self.rear.next = new_node
            self.rear = new_node

    def dequeue(self):
        if self.front is None:
            return None
        dequeued = self.front.data
        self.front = self.front.next
        if self.front is None:
            self.rear = None
        return dequeued

बड़े डेटासेट को संभालना

बड़े डेटासेट से निपटने के दौरान लिंक की गई सूचियाँ भी उपयोगी होती हैं। सरणियों के विपरीत, लिंक की गई सूचियों को सन्निहित मेमोरी आवंटन की आवश्यकता नहीं होती है। इसका मतलब यह है कि लिंक की गई सूचियाँ आकार बदलने या पुनः आवंटन की आवश्यकता के बिना विभिन्न आकारों के डेटासेट को कुशलतापूर्वक संभाल सकती हैं।

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

ग्राफ़ ट्रैवर्सल एल्गोरिदम

ग्राफ़ ट्रैवर्सल एल्गोरिदम, जैसे कि चौड़ाई-पहली खोज (बीएफएस) और गहराई-पहली खोज (डीएफएस), को लिंक की गई सूचियों का उपयोग करके भी कार्यान्वित किया जा सकता है। ग्राफ़ ट्रैवर्सल में, हम ग्राफ़ में प्रत्येक शीर्ष या नोड पर एक विशिष्ट क्रम में जाते हैं।

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

बहुपद निरूपण

लिंक्ड सूचियों का उपयोग बहुपदों को कुशलतापूर्वक दर्शाने के लिए किया जा सकता है। गणित में, बहुपद वे अभिव्यक्तियाँ हैं जिनमें चर और गुणांक होते हैं। बहुपद में प्रत्येक पद को एक लिंक्ड सूची में एक नोड के रूप में दर्शाया जा सकता है, जहां गुणांक और घातांक डेटा के रूप में संग्रहीत होते हैं।

लिंक की गई सूचियों का उपयोग करके, हम बहुपदों पर जोड़, घटाव और गुणा जैसे ऑपरेशन आसानी से कर सकते हैं। इन परिचालनों को करने के लिए नोड्स में हेरफेर किया जा सकता है, जिसके परिणामस्वरूप बहुपदों का संक्षिप्त और कुशल प्रतिनिधित्व होता है।

संगीत और वीडियो प्लेलिस्ट

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

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

निष्कर्ष

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

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

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

आप यहां पायथन सूचियों से संबंधित अधिक लेख भी पढ़ सकते हैं:

आम सवाल-जवाब

सम्बंधित

• एसईओ संचालित सामग्री और पीआर वितरण। आज ही प्रवर्धित हो जाओ।
• प्लेटोडेटा.नेटवर्क वर्टिकल जेनरेटिव एआई। स्वयं को शक्तिवान बनाएं। यहां पहुंचें।
• प्लेटोआईस्ट्रीम। Web3 इंटेलिजेंस। ज्ञान प्रवर्धित। यहां पहुंचें।
• प्लेटोईएसजी. कार्बन, क्लीनटेक, ऊर्जा, पर्यावरण, सौर, कचरा प्रबंधन। यहां पहुंचें।
• प्लेटोहेल्थ। बायोटेक और क्लिनिकल परीक्षण इंटेलिजेंस। यहां पहुंचें।
• स्रोत: https://www.analyticsvidhya.com/blog/2024/02/linked-lists-in-python/