सी ++ में सॉर्ट ट्री मर्ज करें

हमें एक पूर्णांक सरणी, खंड प्रारंभ और अंत पॉइंटर्स का एक सेट और एक कुंजी मान दिया गया है और यहां समस्या कथन दी गई श्रेणी में सभी मानों को ढूंढना है जो दिए गए कुंजी मान से छोटे या बराबर हैं।

उदाहरण के साथ समझते हैं

इनपुट - एआर [] ={7, 8 , 1, 4 , 6 , 8 , 10 }

खंड 1:प्रारंभ =2, अंत =4, के =2

खंड 2:प्रारंभ =1, अंत =6, के =3

आउटपुट − दी गई श्रेणी में कुंजी मान से छोटी या उसके बराबर संख्या की संख्या 2 6

स्पष्टीकरण - [8, 1, 4] 2 से 4 तक की सीमा का प्रतिनिधित्व करता है और 2 इस श्रेणी में दूसरी सबसे छोटी संख्या है [7, 8, 1, 4, 6, 8] 1 से 6 तक की सीमा का प्रतिनिधित्व करता है और 6 तीसरी है श्रेणी में सबसे छोटी संख्या

इनपुट - एआर [] ={2, 7 , 9, 4 , 6 , 5 , 1 |

खंड 1:प्रारंभ =3, अंत =6, के =4

खंड 2:प्रारंभ =2, अंत =5, के =3

आउटपुट − दी गई श्रेणी में प्रमुख मान से छोटी या उसके बराबर संख्या की संख्या हैं:9 7

स्पष्टीकरण - [9, 4, 6, 5] 3 से 6 तक की सीमा का प्रतिनिधित्व करता है और 9 दी गई श्रेणी में चौथी सबसे छोटी संख्या है [7, 9, 4, 6] 2 से 4 तक की सीमा का प्रतिनिधित्व करता है और 7 तीसरी सबसे छोटी संख्या है। दिए गए सेगमेंट रेंज में नंबर

नीचे दिए गए प्रोग्राम में इस्तेमाल किया गया तरीका इस प्रकार है -

• एक पूर्णांक प्रकार सरणी घोषित करें। एक सरणी के आकार की गणना करें। पूर्णांक प्रकारों की जोड़ी बनाने वाला एक वेक्टर प्रकार चर घोषित करें। डेटा को ऐरे से वेक्टर में पुश करने के लिए फॉर लूप प्रारंभ करें।

• दिए गए वेक्टर को क्रमबद्ध करें। MAX आकार के साथ पूर्णांक प्रकारों की एक सदिश सरणी बनाएं।

• फ़ंक्शन को GenerateTree(1, 0, size - 1, vec, tree) के रूप में कॉल करें और getSmallestIndex को queryWrapper(2, 5, 2, size, vec, tree) पर सेट करें।

• इनपुट प्रिंट करें [getSmallestIndex]।

• फ़ंक्शन को queryWrapper(1, 6, 4, size, vec, tree) के रूप में कॉल करने के लिए getSmallestIndex सेट करें।

• फ़ंक्शन के अंदर शून्य उत्पन्न ट्री (इंट ट्रीइंडेक्स, इंट लेफ्टइंडेक्स, इंट राइटइंडेक्स, वेक्टर <जोड़ी <इंट, इंट>> और ए, वेक्टर <इंट> ट्री [])

  • अगर बाएं इंडेक्स को दाएं इंडेक्स पर चेक करें तो सेटट्री [ट्री इंडेक्स]। पुश_बैक (ए [बाएं इंडेक्स]। सेकेंड) और वापसी करें

  • मिडवैल्यू को (लेफ्टइंडेक्स + राइटइंडेक्स) / 2 पर सेट करें और जेनरेट ट्री (2 * ट्रीइंडेक्स, लेफ्टइंडेक्स, मिडवैल्यू, ए, ट्री), जेनरेट ट्री (2 * ट्रीइंडेक्स + 1, मिडवैल्यू + 1, राइटइंडेक्स, ए, ट्री) और मर्ज (ट्री [2 * treeIndex].begin(), tree[2 * treeIndex].end(), tree[2 * treeIndex + 1].begin()। ट्री सेट करें[2 * treeIndex + 1].end(),back_inserter(tree[ ट्रीइंडेक्स]))

• फ़ंक्शन के अंदर इंट कैलकुलेट के रूप में सबसे छोटा (इंट स्टार्टइंडेक्स, इंट एंडइंडेक्स, इंट क्वेरीस्टार्ट, इंट क्वेरीएंड, इंट ट्रीइंडेक्स, इंट की, वेक्टर ट्री [])

  • IF startIndex को endIndex पर चेक करें और फिर ट्री लौटाएं [treeIndex][0]

  • मध्य (स्टार्टइंडेक्स + एंडइंडेक्स) / 2, last_in_query_range से (ऊपरी_बाउंड (ट्री [2 * ट्रीइंडेक्स]। शुरू (), ट्री [2 * ट्रीइंडेक्स]। एंड (), क्वेरीएंड) - ट्री [2 * ट्रीइंडेक्स]। शुरू करें ( ))

  • first_in_query_range को (lower_bound(tree[2 * treeIndex].begin(),tree[2 * treeIndex].end(), queryStart) - tree[2 * treeIndex].begin()) और M से last_in_query_range - first_in_query_range पर सेट करें। पी>

  • जाँच करें कि IF M, कुंजी के बराबर से बड़ा है, फिर कैलकुलेट करेंके सबसे छोटा (स्टार्टइंडेक्स, मिड, क्वेरीस्टार्ट, क्वेरीएंड, 2 * ट्रीइंडेक्स, की, ट्री)

  • ELSE, फिर कैलकुलेट करेंकेसबसे छोटा (मध्य + 1, एंडइंडेक्स, क्वेरीस्टार्ट, क्वेरीएंड, 2 * ट्रीइंडेक्स + 1, की - एम, ट्री)।

• फ़ंक्शन के अंदर int queryWrapper(int queryStart, int queryEnd, int key, int n, vector> &a, vectortree[])

  • फ़ंक्शन पर कॉल वापस करें कैलकुलेट के सबसे छोटा(0, n - 1, क्वेरीस्टार्ट - 1, क्वेरीएंड - 1, 1, कुंजी, ट्री)

उदाहरण

#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000;
void generateTree(int treeIndex, int leftIndex, int rightIndex, vector<pair<int, int> > &a, vector<int> tree[]){
   if (leftIndex == rightIndex){
      tree[treeIndex].push_back(a[leftIndex].second);
      return;
   }
   int midValue = (leftIndex + rightIndex) / 2;
   generateTree(2 * treeIndex, leftIndex, midValue, a, tree);
   generateTree(2 * treeIndex + 1, midValue + 1, rightIndex, a, tree);
   merge(tree[2 * treeIndex].begin(), tree[2 * treeIndex].end(), tree[2 * treeIndex + 1].begin(),
   tree[2 * treeIndex + 1].end(), back_inserter(tree[treeIndex]));
}
int calculateKSmallest(int startIndex, int endIndex, int queryStart, int queryEnd, int treeIndex, int key, vector<int> tree[]){
      if (startIndex == endIndex){
         return tree[treeIndex][0];
      }
      int mid = (startIndex + endIndex) / 2;
      int last_in_query_range = (upper_bound(tree[2 * treeIndex].begin(), tree[2 * treeIndex].end(), queryEnd) - tree[2 * treeIndex].begin());
      int first_in_query_range = (lower_bound(tree[2 * treeIndex].begin(), tree[2 * treeIndex].end(),queryStart) - tree[2 * treeIndex].begin());
      int M = last_in_query_range - first_in_query_range;
      if (M >= key){
         return calculateKSmallest(startIndex, mid, queryStart, queryEnd, 2 * treeIndex, key, tree);
      }
      else {
         return calculateKSmallest(mid + 1, endIndex, queryStart,queryEnd, 2 * treeIndex + 1, key - M, tree);
      }
}
int queryWrapper(int queryStart, int queryEnd, int key, int n,
   vector<pair<int, int> > &a, vector<int> tree[]){
      return calculateKSmallest(0, n - 1, queryStart - 1, queryEnd - 1, 1, key, tree);
}
int main(){
   int input[] = { 7, 8 , 1, 4 , 6 , 8 , 10 };
   int size = sizeof(input)/sizeof(input[0]);
   vector<pair<int, int> > vec;
   for (int i = 0; i < size; i++) {
      vec.push_back(make_pair(input[i], i));
   }
   sort(vec.begin(), vec.end());
   vector<int> tree[MAX];
   generateTree(1, 0, size - 1, vec, tree);

   cout<<"Count of number which are smaller than or equal to key value in the given range are:"<<endl;

   int getSmallestIndex = queryWrapper(2, 4, 2, size, vec, tree);
   cout << input[getSmallestIndex] << endl;
   getSmallestIndex = queryWrapper(1, 6, 3, size, vec, tree);
   cout << input[getSmallestIndex] << endl;
   return 0;
}

आउटपुट

यदि हम उपरोक्त कोड चलाते हैं तो यह निम्न आउटपुट उत्पन्न करेगा

Count of number which are smaller than or equal to key value in the given range are:
4
6