एक समस्या को हल करने के लिए जिसमें हमें एक लिंक्ड लिस्ट में मौजूद पेयरवाइज़ नोड्स को स्वैप करना है और फिर इसे प्रिंट करना है, उदाहरण के लिए
इनपुट: 1->2->3->4->5->6->NULL आउटपुट: 2->1->4->3->6->5->NULL इनपुट: 1->2->3->4->5->NULL आउटपुट: 2->1->4->3->5->NULL इनपुट: 1->NULL आउटपुट: 1->NULL
समाधान के दो तरीके हैं दोनों की समय जटिलता O(N) है, जहां N हमारी प्रदान की गई लिंक्ड लिस्ट का आकार है, तो अब हम दोनों दृष्टिकोणों का पता लगाने जा रहे हैं
इटरेटिव दृष्टिकोण
इस दृष्टिकोण में, हम लिंक्ड लिस्ट के तत्वों के माध्यम से पुनरावृति करेंगे, और उन्हें पेयरवाइज़ स्वैप करेंगे जब तक वे NULL तक नहीं पहुंच जाते।
उदाहरण
#include <bits/stdc++.h> using namespace std; class Node { // हमारी लिस्ट का नोड public: int data; Node* next; }; void swapPairwise(Node* head){ Node* temp = head; while (temp != NULL && temp->next != NULL) { // पेयरवाइज़ स्वैप के लिए हमें 2 नोड्स की आवश्यकता होती है इसलिए हम चेक कर रहे हैं swap(temp->data, temp->next->data); // डेटा स्वैप करना temp = temp->next->next; // अगले जोड़े पर जाना } } void push(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; // हमारा नया नोड हमारा हेड बन जाता है } void printList(Node* node){ // दी गई लिंक्ड लिस्ट को प्रिंट करने का यूटिलिटी फंक्शन while (node != NULL) { cout << node->data << " "; node = node->next; } } int main(){ Node* head = NULL; push(&head, 5); push(&head, 4); push(&head, 3); push(&head, 2); push(&head, 1); cout << "Linked list before\n"; printList(head); swapPairwise(head); cout << "\nLinked list after\n"; printList(head); return 0; }आउटपुट
Linked list before 1 2 3 4 5 Linked list after 2 1 4 3 5
हम अपने अगले दृष्टिकोण में उसी सूत्र का उपयोग करेंगे, लेकिन हम रिकर्सन के माध्यम से पुनरावृति करेंगे।
रिकर्सिव दृष्टिकोण
इस दृष्टिकोण में, हम उसी तर्क को रिकर्सन के साथ लागू कर रहे हैं।
उदाहरण
#include <bits/stdc++.h> using namespace std; class Node { // हमारी लिस्ट का नोड public: int data; Node* next; }; void swapPairwise(struct Node* head){ if (head != NULL && head->next != NULL) { // वही शर्त जो हमारे इटरेटिव में थी swap(head->data, head->next->data); // डेटा स्वैप करना swapPairwise(head->next->next); // अगले जोड़े पर जाना } return; // अन्यथा वापस लौटना } void push(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; // हमारा नया नोड हमारा हेड बन जाता है } void printList(Node* node){ // दी गई लिंक्ड लिस्ट को प्रिंट करने का यूटिलिटी फंक्शन while (node != NULL) { cout << node->data << " "; node = node->next; } } int main(){ Node* head = NULL; push(&head, 5); push(&head, 4); push(&head, 3); push(&head, 2); push(&head, 1); cout << "Linked list before\n"; printList(head); swapPairwise(head); cout << "\nLinked list after\n"; printList(head); return 0; }आउटपुट
Linked list before 1 2 3 4 5 Linked list after 2 1 4 3 5
उपरोक्त कोड की व्याख्या
इस दृष्टिकोण में, हम अपनी लिंक्ड लिस्ट को जोड़े में पार करते हैं। अब, जैसे ही हम एक जोड़े पर पहुंचते हैं, हम उनके डेटा को स्वैप करते हैं और अगले जोड़े पर चले जाते हैं, और इस तरह हमारा प्रोग्राम दोनों विधियों में आगे बढ़ता है।
निष्कर्ष
इस ट्यूटोरियल में, हम दी गई लिंक्ड लिस्ट के पेयरवाइज़ तत्वों को रिकर्सन और इटरेशन का उपयोग करके स्वैप करते हैं। हमने इस समस्या के लिए C++ प्रोग्राम और पूरा दृष्टिकोण (सामान्य) भी सीखा जिससे हमने इस समस्या को हल किया। हम यही प्रोग्राम C, Java, Python, और अन्य भाषाओं में भी लिख सकते हैं। आशा है आपको यह ट्यूटोरियल उपयोगी लगा होगा।