सी ++ में बीएसटी में दिए गए योग के साथ एक जोड़ी खोजें

इस ट्यूटोरियल में, हम एक प्रोग्राम लिखने जा रहे हैं जो उस जोड़ी को ढूंढता है जिसका योग बाइनरी सर्च ट्री में दी गई संख्या के बराबर है।

हम जोड़े को खोजने के लिए दो अलग-अलग सूचियों में पेड़ों के मूल्यों को संग्रहीत करने जा रहे हैं। आइए समस्या को हल करने के लिए चरणों को देखें।

बाइनरी ट्री के लिए एक स्ट्रक्चर नोड बनाएं।
बाइनरी सर्च ट्री में एक नया नोड डालने के लिए एक फ़ंक्शन लिखें।
- याद रखें, बाइनरी सर्च ट्री में वे सभी तत्व जो रूट से छोटे होते हैं वे छोटे होते हैं, और दाएं बड़े होते हैं।
ट्री के बाएँ और दाएँ नोड्स को संग्रहीत करने के लिए दो खाली सूचियों को प्रारंभ करें।
बायनेरी सर्च ट्री पर तब तक पुनरावृति करें जब तक कि बाएँ या दाएँ नोड NULL न हों या दोनों सूचियाँ खाली न हों।
- सभी तत्वों को बाईं नोड सूची में संग्रहीत करने के लिए एक लूप लिखें।
- सभी तत्वों को सही नोड्स सूची में संग्रहीत करने के लिए एक लूप लिखें।
- प्रत्येक सूची से अंतिम नोड प्राप्त करें।
- दो मानों की जाँच करें।
  - यदि लेफ्ट साइड नोड वैल्यू राइट साइड नोड वैल्यू से अधिक या उसके बराबर है, तो लूप को तोड़ दें।
  - यदि दो मानों का योग दी गई संख्या के बराबर है, तो लूप को प्रिंट करके तोड़ दें।
  - यदि दो मानों का योग दी गई संख्या से कम है, तो बाईं सूची से अंतिम नोड को हटा दें और नोड के दाईं ओर ले जाएँ।
  - यदि दो मानों का योग दी गई संख्या से अधिक है, तो दाएँ सूची से अंतिम नोड को हटाएँ और नोड के बाईं ओर जाएँ।

उदाहरण

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

#include<bits/stdc++.h>
using namespace std;
struct Node{
   int data;
   Node *left, *right, *root;
   Node(int data) {
      this->data = data;
      left = NULL;
      right = NULL;
      root = NULL;
   }
};
Node* insertNewNode(Node *root, int data){
   if (root == NULL) {
      root = new Node(data);
      return root;
   }
   if (root->data < data) {
      root->right = insertNewNode(root->right, data);
   }
   else if (root->data > data) {
      root->left = insertNewNode(root->left, data);
   }
   return root;
}
void findThePairs(Node *node, int target) {
   vector<Node*> left_side_nodes;
   vector<Node*> right_side_nodes;
   Node *current_left = node;
   Node *current_right = node;
   while (current_left != NULL || current_right != NULL || (left_side_nodes.size() > 0 && right_side_nodes.size() > 0)) {
      while (current_left != NULL) {
         left_side_nodes.push_back(current_left);
         current_left = current_left->left;
      }
      while (current_right != NULL) {
         right_side_nodes.push_back(current_right);
         current_right = current_right->right;
      }
      Node *left_side_node = left_side_nodes[left_side_nodes.size() - 1];
      Node *right_side_node = right_side_nodes[right_side_nodes.size() - 1];
      int left_side_value = left_side_node->data;
      int right_side_value = right_side_node->data;
      if (left_side_value >= right_side_value) {
         break;
      }
      if (left_side_value + right_side_value < target) {
         left_side_nodes.pop_back();
         current_left = left_side_node->right;
      }
      else if (left_side_value + right_side_value > target) {
         right_side_nodes.pop_back();
         current_right = right_side_node->left;
      }
      else {
         cout << left_side_node->data << " " << right_side_node->data << endl;
         break;
      }
   }
}
int main() {
   Node *root = NULL;
   root = insertNewNode(root, 25);
   root = insertNewNode(root, 20);
   root = insertNewNode(root, 30);
   root = insertNewNode(root, 15);
   root = insertNewNode(root, 21);
   root = insertNewNode(root, 19);
   root = insertNewNode(root, 31);
   findThePairs(root, 36);
}

आउटपुट

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

15 21

निष्कर्ष

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