• Home
  • /
  • Blog
  • /
  • 2 बेसिक लिंक्ड लिस्ट ऑपरेशंस बच्चों के लाभ के लिए

2 बेसिक लिंक्ड लिस्ट ऑपरेशंस बच्चों के लाभ के लिए

बेसिक लिंक्ड लिस्ट ऑपरेशंस बच्चों के लाभ के लिए

This post is also available in: English (English) العربية (Arabic)

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

2 मूल लिंक्ड लिस्ट ऑपरेशन्स

एक लिस्ट द्वारा समर्थित मूल ऑपरेशन्स निम्नलिखित हैं।

  • सम्मिलन (इंसर्शन) – लिस्ट में एक तत्व जोड़ता है।
  • विलोपन (डिलीशन) – लिस्ट से एक तत्व हटाता है।

एक नोड का सम्मिलन (इंसर्शन)

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

नोड का सम्मिलन (इंसर्शन) – सिंपल लिंक्ड लिस्ट

एक सिंपल लिंक्ड लिस्ट में एक नया नोड सम्मिलित करने के लिए इस दृष्टिकोण का पालन किया जाता है

  • लिंक्ड लिस्ट को स्थिति p1 पर ले जाना (p1 वह स्थिति है जहां नया नोड डाला जाता है)।
  • एक बार जब p1 तक सभी नोड्स ट्रैवर्स हो जाएँ, तब तक मेमोरी और नए नोड को डेटा आवंटित करें।
  • नए नोड के अगले पॉइंटर को वर्तमान नोड के अगले पर इंगित करें।
  • वर्तमान नोड के अगले नोड पर इंगित करें।
लिंक्ड लिस्ट पर संचालन
सम्मिलन (इंसर्शन) – सिंपल लिंक्ड लिस्ट

C ++ में सिंपल लिंक्ड लिस्ट में सम्मिलन के लिए कोड

struct Node
{
   int data;
   struct Node *next;
};
void insert(struct Node* prev_node, int node_data)
{
if (prev_node == NULL)
{
   cout<<"the given previous node is required,cannot be NULL"; return; }
   struct Node* newNode =new Node;
   newNode->data = node_data;
   newNode->next = prev_node->next;
    prev_node->next = newNode;
}
int main()
{
struct Node* head = NULL;
insert(head->next, 50);
return 0;
}

एक नोड की प्रविष्टि (इंसर्शन) – डबली लिंक्ड लिस्ट

डबली लिंक्ड लिस्ट में एक नया नोड सम्मिलित करने के लिए इस दृष्टिकोण का पालन किया जाता है

  • लिस्ट में नोड (p – 1) तक ट्रैवर्स करें, जहां p इंसर्शन की स्थिति है।
  • एक नया नोड बनाएं और डेटा को उसके डेटा फ़ील्ड में असाइन करें।
  • (p -1) नोड के अगले एड्रेस द्वारा इंगित नोड के साथ एक नए नोड के अगले एड्रेस को कनेक्ट करें।
  • नए नोड के पिछले एड्रेस फ़ील्ड को (p – 1) नोड से कनेक्ट करें।
  • जांचें कि क्या (p – 1) नोड का अगला एड्रेस NULL तो नहीं है, फिर नोड के अगले एड्रेस (p – 1) को नए नोड से कनेक्ट करें।
  • (p – 1) नोड के अगले (नेक्स्ट) को एक नए नोड से कनेक्ट करें।
लिंक्ड लिस्ट पर संचालन
इंसर्शन – डबली लिंक्ड लिस्ट

C ++ में डबली-लिंक्ड लिस्ट में सम्मिलन के लिए कोड

struct Node {
   int data;
   struct Node* next;
   struct Node* prev;
};
void insert(struct Node* prev_node, int new_data)
{
   if (prev_node == NULL) {
   cout<<"Previous node is required , it cannot be NULL";
   return;
}
   struct Node* newNode = new Node;
   newNode->data = new_data;
   newNode->next = prev_node->next;
   prev_node->next = newNode;
   newNode->prev = prev_node;
   if (newNode->next != NULL)
   newNode->next->prev = newNode;
}
int main() {
   struct Node* head = NULL;
   insert(head->next, 30);
   return 0;
}

एक नोड का विलोपन (डिलीशन)

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

एक नोड का विलोपन – सिंपल लिंक्ड लिस्ट

एक साधारण लिंक्ड लिस्ट से नोड को हटाने के लिए इस दृष्टिकोण का पालन किया जाता है

  • हटाए जाने वाले नोड के पिछले नोड का पता लगाएं।
  • पिछले नोड के अगले (नेक्स्ट) को बदलें।
  • नोड को डिलीट करने के लिए मेमोरी फ्री (खाली) करें।
लिंक्ड लिस्ट पर संचालन
विलोपन (डिलीशन) – सिंपल लिंक्ड लिस्ट

C ++ में सिंपल लिंक्ड लिस्ट में विलोपन के लिए कोड

struct node{
    int data;
    node* next;
};
void delete_node(node** head,int x){
    if((*head)->next==NULL){
        *head=NULL;
        return;
    }
    struct node* temp=*head;
    if(temp->data==x){
    	temp=temp->next;
    	*head=temp;
    	return;
    }
    while(temp){
    	if(temp->data==x){
    		temp->data=temp->next->data;
    		temp->next=temp->next->next;
    		break;
    	}
    	temp=temp->next;
    }
}
int main()
{
    struct node* n=NULL;
    delete_node(&n,2);
   return 0;
}

एक नोड का विलोपन – डबली लिंक्ड लिस्ट

डबली-लिंक्ड लिस्ट से नोड को हटाने के लिए इस दृष्टिकोण का पालन किया जाता है

  • आवश्यक स्थिति तक पहुंचने तक हेड से लिंक्ड लिस्ट को ट्रैवर्स करें (इस स्थान को temp मानें)।
  • temp के पिछले पॉइंटर के अगले पॉइंटर के पॉइंटर को असाइन करें।
  • temp के पिछले पॉइंटर को temp के अगले नोड के पिछले पॉइंटर को असाइन करें।
  • temp नोड को फ्री (खाली) करें।
लिंक्ड लिस्ट पर संचालन
विलोपन – डबली लिंक्ड लिस्ट

C ++ में डबली लिंक्ड लिस्ट में विलोपन के लिए कोड

struct node {
   int data;
   struct node *prev;
   struct node *next;
};
void remove_data(int data) {
   int pos = 0;
   struct node *pre_node;
   if(head->data == data) {
      if(head->next != NULL) {
         head->next->prev = NULL;
         head = head->next;
         return;
      } else {
         head = NULL;
         return;
      }
   } else if(head->data != data && head->next == NULL) {
      printf("%d not found in the list\n", data);
      return;
   }
   current = head;
   while(current->next != NULL && current->data != data) {
      pre_node = current;
      current = current->next;
   }        
   if(current->data == data) {
      pre_node->next = pre_node->next->next;
      if(pre_node->next != NULL) {          // link back
         pre_node->next->prev = pre_node;
      } else
         last = pre_node;
      free(current);
   } else
      printf("%d not found in the list.", data);
}
int main() {
   remove_data(20);
   return 0;
}
{"email":"Email address invalid","url":"Website address invalid","required":"Required field missing"}
>