एक समस्या को हल करने के लिए जिसमें हमें एक लिंक्ड सूची में मौजूद जोड़ीदार नोड्स को स्वैप करना होता है और फिर इसे प्रिंट करना होता है, उदाहरण के लिए
Input : 1->2->3->4->5->6->NULL Output : 2->1->4->3->6->5->NULL Input : 1->2->3->4->5->NULL Output : 2->1->4->3->5->NULL Input : 1->NULL Output : 1->NULL
ओ (एन) की समय जटिलता दोनों के समाधान तक पहुंचने के दो तरीके हैं, जहां एन हमारी प्रदान की गई लिंक्ड सूची का आकार है, इसलिए अब हम दोनों दृष्टिकोणों का पता लगाने जा रहे हैं
पुनरावर्ती दृष्टिकोण
हम इस दृष्टिकोण में लिंक किए गए सूची तत्वों के माध्यम से पुनरावृति करेंगे, और जब तक वे NULL तक नहीं पहुंच जाते, तब तक उन्हें जोड़ीदार स्वैप करते हैं।
उदाहरण
#include <bits/stdc++.h>
using namespace std;
class Node { // node of our list
public:
int data;
Node* next;
};
void swapPairwise(Node* head){
Node* temp = head;
while (temp != NULL && temp->next != NULL) { // for pairwise swap we need to have 2 nodes hence we are checking
swap(temp->data,
temp->next->data); // swapping the data
temp = temp->next->next; // going to the next pair
}
}
void push(Node** head_ref, int new_data){ // function to push our data in list
Node* new_node = new Node(); // creating new node
new_node->data = new_data;
new_node->next = (*head_ref); // head is pushed inwards
(*head_ref) = new_node; // our new node becomes our head
}
void printList(Node* node){ // utility function to print the given linked list
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 { // node of our list
public:
int data;
Node* next;
};
void swapPairwise(struct Node* head){
if (head != NULL && head->next != NULL) { // same condition as our iterative
swap(head->data, head->next->data); // swapping data
swapPairwise(head->next->next); // moving to the next pair
}
return; // else return
}
void push(Node** head_ref, int new_data){ // function to push our data in list
Node* new_node = new Node(); // creating new node
new_node->data = new_data;
new_node->next = (*head_ref); // head is pushed inwards
(*head_ref) = new_node; // our new node becomes our head
}
void printList(Node* node){ // utility function to print the given linked list
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++ प्रोग्राम और संपूर्ण दृष्टिकोण (Normal) भी सीखा जिसके द्वारा हमने इस समस्या को हल किया। हम उसी प्रोग्राम को अन्य भाषाओं जैसे सी, जावा, पायथन और अन्य भाषाओं में लिख सकते हैं। हमें उम्मीद है कि आपको यह ट्यूटोरियल मददगार लगा होगा।