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

पाठ्यक्रम की रूपरेखा

1. परिचय
2. एकल लिंक्ड सूचियों को कार्यान्वित करना
   • नया नोड बनाना
   • शुरुआत में डालें
   • अंत में डालें
   • एक नोड हटाएं
   • नोड खोजें
   • सूची को पार करें
3. निष्कर्ष

परिचय

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

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

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

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

अब, हमारी एकल लिंक्ड सूची के बुनियादी कार्यों को लागू करना शुरू करने का समय आ गया है। क्या हम?

नया नोड बनाना

आइए एक नया नोड क्लास बनाकर शुरुआत करें। नोड क्लास में एक कंस्ट्रक्टर होगा जो नोड के लिए डेटा लेता है और एक अगला पॉइंटर होता है जो शुरू में शून्य पर सेट होता है।

// Node class for Singly Linked List
class Node {
  constructor(data) {
    this.data = data;
    this.next = null;
  }
}

यह नव निर्मित नोड वर्ग (जो लिंक की गई सूची में एक नोड का प्रतिनिधित्व करता है) को नीचे के रूप में देखा जा सकता है।

आगे बढ़ने से पहले, आइए अपने SinglyLinkedList वर्ग का एक नया उदाहरण बनाएं जो हमारी लिंक की गई सूची संचालन को बनाए रखेगा।

// Singly Linked List class
class SinglyLinkedList {
  constructor() {
    this.head = null;
  }

  // Operations come here ?
}

शुरुआत में डालें

class SinglyLinkedList {
  constructor() {
    this.head = null;
  }
  // Previous `SinglyLinkedList` class codes here ?
  // .
  // .
  // .
  // Insert at the beginning
  insertAtBeginning(data) {
    const newNode = new Node(data); // Create a new node with the given data
    newNode.next = this.head; // Set the new node's next pointer to the current head
    this.head = newNode; // Update the head to be the new node
  }

  // Other operations come here ?
  // .
  // .
  // .
}

स्पष्टीकरण: शुरुआत में सम्मिलित करना किसी नए व्यक्ति के सामने पंक्ति में शामिल होने जैसा है। वे पिछले पहले से जुड़कर नए पहले व्यक्ति बन जाते हैं।

अंत में डालें

class SinglyLinkedList {
  constructor() {
    this.head = null;
  }
  // Previous `SinglyLinkedList` class codes here ?
  // .
  // .
  // .
  // Insert at the end
  insertAtEnd(data) {
    const newNode = new Node(data); // Create a new node with the given data

    // check if the list does not have a head i.e the list is empty
    // NOTE: Every non-empty linked list will have a head
    if (!this.head) {
      this.head = newNode; // If the list is empty, set the new node as the head
      return;
    }
    let current = this.head; // Start at the head of the list
    while (current.next) {
      current = current.next; // Move to the next node in the list by updating the current node
    }
    current.next = newNode; // Set the next pointer of the last node to the new node
  }

  // Other operations come here ?
  // .
  // .
  // .
}

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

एक नोड हटाएँ

class SinglyLinkedList {
  constructor() {
    this.head = null;
  }

  // Previous `SinglyLinkedList` class codes here ?
  // .
  // .
  // .

  // Delete a node
  deleteNode(data) {
    if (!this.head) return; // If the list is empty, do nothing
    if (this.head.data === data) {
      this.head = this.head.next; // If the node to delete is the head, update the head to the next node
      return;
    }
    let current = this.head;
    while (current.next) {
      if (current.next.data === data) {
        current.next = current.next.next; // If the node to delete is found, update the next pointer to skip it
        return;
      }
      current = current.next;
    }
  }

  // Other operations come here ?
  // .
  // .
  // .
}

स्पष्टीकरण: किसी नोड को हटाना पंक्ति के बीच में मौजूद किसी व्यक्ति द्वारा छोड़ने का निर्णय लेने जैसा है। हम उस व्यक्ति को ढूंढते हैं और उससे पहले वाले को उसके बाद वाले से जोड़ते हैं।

एक नोड खोजें

class SinglyLinkedList {
  constructor() {
    this.head = null;
  }

  // Previous `SinglyLinkedList` class codes here ?
  // .
  // .
  // .

  // Search note
  search(data) {
    let current = this.head; // Start at the head of the list
    while (current) {
      if (current.data === data) {
        // If the data is found, return true
        return true;
      }
      current = current.next; // Move to the next node
    }
    return false;
  }

  // Other operations come here ?
  // .
  // .
  // .
}

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

सूची को पार करें

class SinglyLinkedList {
  constructor() {
    this.head = null;
  }
  // Previous `SinglyLinkedList` class codes here ?
  // .
  // .
  // .
  traverse() {
    let current = this.head; // Start at the head of the list
    while (current) {
      console.log(current.data); // Print the data of the current node
      current = current.next; // Move to the next node
    }
  }
}

// End of class

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

निष्कर्ष

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

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

अपडेट और कनेक्टेड रहें

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

• गिटहब
• लिंक्डइन
• एक्स (ट्विटर)

बने रहें और खुश रहें कोडिंग ?‍??