Computer >> कंप्यूटर >  >> प्रोग्रामिंग >> C++

C++ में सिंगल लिंक्ड लिस्ट से सभी नॉन-प्राइम नोड्स को डिलीट करें

इस ट्यूटोरियल में, हम सीखेंगे कि सिंगल लिंक्ड लिस्ट से सभी प्राइम नोड्स को कैसे डिलीट किया जाए।

आइए समस्या को हल करने के लिए चरणों को देखें।

  • डेटा और अगले पॉइंटर के साथ स्ट्रक्चर लिखें।

  • नोड को सिंगल लिंक्ड लिस्ट में डालने के लिए एक फंक्शन लिखें।

  • डमी डेटा के साथ सिंगल लिंक्ड लिस्ट को इनिशियलाइज़ करें।

  • एकल लिंक की गई सूची पर पुनरावृति करें। पता करें कि वर्तमान नोड डेटा प्राइम है या नहीं।

  • यदि वर्तमान डेटा प्राइम नहीं है, तो नोड को हटा दें।

  • नोड को हटाने के लिए एक फ़ंक्शन लिखें। नोड को हटाते समय निम्नलिखित तीन मामलों पर विचार करें।

    • अगर नोड हेड नोड है, तो हेड को अगले नोड पर ले जाएं।

    • यदि नोड मध्य नोड है, तो अगले नोड को पिछले नोड से लिंक करें

    • यदि नोड अंतिम नोड है, तो पिछले नोड लिंक को हटा दें।

उदाहरण

आइए कोड देखें।

#include <bits/stdc++.h>
using namespace std;
struct Node {
   int data;
   Node* next;
};
void insertNode(Node** head_ref, int new_data) {
   Node* new_node = new Node;
   new_node->data = new_data;
   new_node->next = (*head_ref);
   (*head_ref) = new_node;
}
bool isPrime(int n) {
   if (n <= 1) {
      return false;
   }
   if (n <= 3) {
      return true;
   }
   if (n % 2 == 0 || n % 3 == 0) {
      return false;
   }
   for (int i = 5; i * i <= n; i = i + 6) {
      if (n % i == 0 || n % (i + 2) == 0) {
         return false;
      }
   }
   return true;
}
void deleteNonPrimeNodes(Node** head_ref) {
   Node* ptr = *head_ref;
   while (ptr != NULL && !isPrime(ptr->data)) {
      Node *temp = ptr;
      ptr = ptr->next;
      delete(temp);
   }
   *head_ref = ptr;
   if (ptr == NULL) {
      return;
   }
   Node *curr = ptr->next;
   while (curr != NULL) {
      if (!isPrime(curr->data)) {
         ptr->next = curr->next;
         delete(curr);
         curr = ptr->next;
      }
      else {
         ptr = curr;
         curr = curr->next;
      }
   }
}
void printLinkedList(Node* head) {
   while (head != NULL) {
      cout << head->data << " -> ";
      head = head->next;
   }
}
int main() {
   Node* head = NULL;
   insertNode(&head, 1);
   insertNode(&head, 2);
   insertNode(&head, 3);
   insertNode(&head, 4);
   insertNode(&head, 5);
   insertNode(&head, 6);
   cout << "Linked List before deletion:" << endl;
   printLinkedList(head);
   deleteNonPrimeNodes(&head);
   cout << "\nLinked List after deletion:" << endl;
   printLinkedList(head);
}

आउटपुट

यदि आप उपरोक्त कोड चलाते हैं, तो आपको निम्न परिणाम प्राप्त होंगे।

Linked List before deletion:
6 -> 5 -> 4 -> 3 -> 2 -> 1 ->
Linked List after deletion:
5 -> 3 -> 2 ->

निष्कर्ष

यदि ट्यूटोरियल में आपके कोई प्रश्न हैं, तो उनका टिप्पणी अनुभाग में उल्लेख करें।


  1. C++ में सिंगल लिंक्ड लिस्ट में सभी प्राइम नोड्स का उत्पाद

    एन नोड्स के साथ दिया गया और कार्य एक लिंक्ड सूची में सभी प्राइम नोड्स के उत्पाद को प्रिंट करना है। प्राइम नोड्स वे हैं जिनके पास उनके गिनती स्थानों के रूप में प्रमुख मान होंगे। इनपुट 10 20 30 40 50 आउटपुट 4,00,000 स्पष्टीकरण -10 इंडेक्स वैल्यू 1 पर है जो नॉन-प्राइम है इसलिए इसे छोड़ दिया जाएगा।

  1. C++ में दिए गए नोड से k दूरी पर सभी नोड्स प्रिंट करें

    इस समस्या में, हमें एक बाइनरी ट्री, एक लक्ष्य नोड और एक पूर्णांक K दिया जाता है। हमें ट्री के सभी नोड्स को प्रिंट करना होता है जो लक्ष्य नोड से K की दूरी पर होते हैं। । बाइनरी ट्री एक विशेष पेड़ है जिसके प्रत्येक नोड में अधिकतम दो नोड (एक/दो/कोई नहीं) होते हैं। आइए समस्या को समझने के लिए एक उदाहरण

  1. सर्कुलर सिंगल लिंक्ड लिस्ट को लागू करने के लिए C++ प्रोग्राम

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