C++ में लिंक्ड लिस्ट द्वारा दर्शाई गई दो संख्याओं को गुणा करना

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

इनपुट

1 -> 2 -> NULL 2 -> 3 -> NULL

आउटपुट

2 -> 7 -> 6 -> NULL

एल्गोरिदम

• दो लिंक्ड लिस्ट आरंभ करें।
• दो वेरिएबल 0 से आरंभ करें ताकि दो संख्याएं स्टोर की जा सकें।
• दोनों लिंक्ड लिस्ट पर पुनरावृति करें।
• प्रत्येक अंक को संबंधित संख्या वेरिएबल के अंत में जोड़ें।
• परिणामी संख्याओं को गुणा करें और परिणाम को एक वेरिएबल में स्टोर करें।
• परिणाम के साथ एक नई लिस्ट बनाएं।
• नई लिस्ट प्रिंट करें।

कार्यान्वयन

निम्नलिखित C++ में उपरोक्त एल्गोरिदम का कार्यान्वयन है:

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

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

void addNewNode(struct Node** head, int new_data) { 
    struct Node* newNode = new Node; 
    newNode->data = new_data; 
    newNode->next = *head; 
    *head = newNode; 
} 

void multiplyTwoLinkedLists(struct Node* firstHead, struct Node* secondHead , struct Node** newLinkedListHead) { 
    int _1 = 0, _2 = 0; 
    while (firstHead || secondHead) { 
        if (firstHead) { 
            _1 = _1 * 10 + firstHead->data; 
            firstHead = firstHead->next; 
        } 
        if (secondHead) { 
            _2 = _2 * 10 + secondHead->data; 
            secondHead = secondHead->next; 
        } 
    } 
    int result = _1 * _2; 
    while (result) { 
        addNewNode(newLinkedListHead, result % 10); 
        result /= 10; 
    } 
} 

void printLinkedList(struct Node *node) { 
    while(node != NULL) { 
        cout << node->data << "->"; 
        node = node->next; 
    } 
    cout << "NULL" << endl; 
} 

int main(void) { 
    struct Node* firstHead = NULL; 
    struct Node* secondHead = NULL; 
    addNewNode(&firstHead, 1); 
    addNewNode(&firstHead, 2); 
    addNewNode(&firstHead, 3); 
    printLinkedList(firstHead); 
    addNewNode(&secondHead, 1); 
    addNewNode(&secondHead, 2); 
    printLinkedList(secondHead); 
    struct Node* newLinkedListHead = NULL; 
    multiplyTwoLinkedLists(firstHead, secondHead, &newLinkedListHead); 
    printLinkedList(newLinkedListHead); 
    return 0; 
}

आउटपुट

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

3->2->1->NULL 2->1->NULL 6->7->4->1->NULL