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

C++ में डबल लिंक्ड लिस्ट से सभी अभाज्य नोड्स को डिलीट करना


परिचय

इस ट्यूटोरियल में हम सीखेंगे कि C++ में डबल लिंक्ड लिस्ट से सभी अभाज्य (prime) मान वाले नोड्स को कैसे हटाया जाता है। डबल लिंक्ड लिस्ट में प्रत्येक नोड में पिछले और अगले दोनों नोड्स के पॉइंटर्स होते हैं, जिससे डिलीट ऑपरेशन आसान हो जाता है।

समस्या समाधान के चरण

  1. डेटा, prev और next पॉइंटर्स के साथ एक स्ट्रक्चर परिभाषित करें।
  2. डबल लिंक्ड लिस्ट में नोड डालने का फंक्शन लिखें।
  3. डमी डेटा के साथ लिस्ट को इनिशियलाइज़ करें।
  4. लिस्ट पर पुनरावृत्ति करें और जांचें कि वर्तमान नोड का डेटा अभाज्य है या नहीं।
  5. यदि डेटा अभाज्य है, तो उस नोड को डिलीट करें।
  6. नोड डिलीट करने का फंक्शन लिखते समय तीन स्थितियों पर विचार करें:
    • यदि नोड हेड नोड है, तो हेड को अगले नोड पर ले जाएं।
    • यदि नोड मध्य में है, तो अगले नोड को पिछले नोड से लिंक करें।
    • यदि नोड अंतिम है, तो पिछले नोड का लिंक हटा दें।

उदाहरण कोड

#include <bits/stdc++.h>
using namespace std;

struct Node {
    int data;
    Node *prev, *next;
};

void insertNode(Node** head_ref, int new_data) {
    Node* new_node = (Node*)malloc(sizeof(struct Node));
    new_node->data = new_data;
    new_node->prev = NULL;
    new_node->next = (*head_ref);
    if ((*head_ref) != NULL) {
        (*head_ref)->prev = new_node;
    }
    (*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 deleteNode(Node** head_ref, Node* del) {
    if (*head_ref == NULL || del == NULL) return;
    if (*head_ref == del) *head_ref = del->next;
    if (del->next != NULL) del->next->prev = del->prev;
    if (del->prev != NULL) del->prev->next = del->next;
    free(del);
}

void deletePrimeNodes(Node** head_ref) {
    Node* temp = *head_ref;
    Node* next;
    while (temp != NULL) {
        next = temp->next;
        if (isPrime(temp->data)) {
            deleteNode(head_ref, temp);
        }
        temp = 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);
    deletePrimeNodes(&head);
    cout << "\nLinked List after deletion:" << endl;
    printLinkedList(head);
    return 0;
}

आउटपुट

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

निष्कर्ष

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


  1. 2D मैट्रिक्स से लिंक्ड लिस्ट बनाएं C++ में (पुनरावर्ती दृष्टिकोण) 2D मैट्रिक्स से लिंक्ड लिस्ट बनाएं C++ में (पुनरावर्ती दृष्टिकोण)

    मान लीजिए हमारे पास एक मैट्रिक्स है, हमें इसे पुनरावर्ती दृष्टिकोण का उपयोग करके 2D लिंक्ड लिस्ट में बदलना है। इस लिस्ट में राइट (दायां) और डाउन (नीचे) पॉइंटर होंगे। उदाहरण के लिए, यदि इनपुट इस तरह का है: 10 20 30 40 50 60 70 80 90 तो आउटपुट होगा: इसे हल करने के लिए, हम निम्न चरणों का पाल

  1. C++ में एकल लिंक्ड सूची में सभी अभाज्य नोड्स का गुणनफल C++ में एकल लिंक्ड सूची में सभी अभाज्य नोड्स का गुणनफल

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

  1. C++ में सर्कुलर लिंक्ड लिस्ट में नोड्स की गिनती करें C++ में सर्कुलर लिंक्ड लिस्ट में नोड्स की गिनती करें

    हमें नोड्स के साथ एक सर्कुलर लिंक्ड लिस्ट दी गई है और कार्य सर्कुलर लिंक्ड लिस्ट में मौजूद नोड्स की संख्या की गणना करना है। सर्कुलर लिंक्ड लिस्ट लिंक्ड लिस्ट का एक प्रकार है जिसमें पहला तत्व अंतिम तत्व की ओर इंगित करता है और अंतिम तत्व पहले तत्व की ओर इंगित करता है। सिंगली लिंक्ड लिस्ट और डबली लिं