सी ++ प्रोग्राम बी-ट्री का उपयोग करके छँटाई करने के लिए

यहां हम देखेंगे कि बी-ट्री का उपयोग करके क्रमबद्ध अनुक्रम कैसे प्राप्त करें। B-वृक्ष n-आर्य वृक्ष है। क्रमबद्ध अनुक्रम प्राप्त करने के लिए, हम एक बी-पेड़ बना सकते हैं, फिर उसमें संख्याएं जोड़ सकते हैं। यहां बी-ट्री अधिकतम 5 नोड्स धारण कर सकता है। यदि नोड्स की संख्या बढ़ती है, तो नोड को विभाजित करें और नया स्तर बनाएं। चूंकि नोड्स में 5 (अधिकतम) जैसे कुछ तत्व हैं, इसलिए हम उन्हें सॉर्ट करने के लिए बबल सॉर्टिंग तकनीकों का उपयोग कर रहे हैं। चूंकि तत्वों की संख्या बहुत कम है, तो यह इसके प्रदर्शन पर बहुत अधिक प्रभाव नहीं डालेगा।

पेड़ को पार करने के बाद, हम विभिन्न नोड्स के सभी मान प्राप्त करेंगे। इन तत्वों को घटते क्रम में क्रमबद्ध किया जाएगा।

एल्गोरिदम

ट्रैवर्स(p)

इनपुट:ट्री नोड p
आउटपुट:पेड़ का ट्रैवर्सल अनुक्रम

मैं के लिए 0 से n-1 की सीमा में शुरू करें, यदि p एक लीफ नोड नहीं है, तो ट्रैवर्स (स्थिति i पर p का बच्चा) समाप्त होता है यदि डेटा को उस स्थिति में प्रिंट करें जो मैंने किया है यदि p एक लीफ नोड नहीं है, फिर ट्रैवर्स (पी का बच्चा स्थिति i पर) अंत ifEnd

सॉर्ट (ए, एन)

इनपुट सरणी a लें, जिसे सॉर्ट किया जाएगा, उस सरणी में तत्वों की संख्या, जो n है

आउटपुट:क्रमबद्ध सरणी

i के लिए 0 से n-1 तक शुरू करें, j के लिए 0 से n-1 तक करें, यदि a[i]> a[j] करें, तो a[i] और a[j] अंत को स्वैप करें यदि किया हुआसमाप्त

split_node(x, i):

इनपुट:नोड x को विभाजित किया जाना है, मैं लीफ नोड के लिए (-1) होगा, अन्यथा कुछ सकारात्मक मूल्य

आउटपुट:बंटवारे के बाद नोड का मध्य तत्व

शुरू करें एक नोड np3 बनाएं, और इसे लीफ नोड के रूप में चिह्नित करें यदि i -1 है, तो मध्य:=x की स्थिति 2 से डेटा x से 0 की स्थिति 2 पर डेटा सेट करें x में डेटा की संख्या को 1 से कम करें np1 नामक एक नया नोड बनाएं, और इसे गैर-पत्ती नोड के रूप में चिह्नित करें x को लीफ नोड के रूप में चिह्नित करें x के सभी नोड्स को स्थिति 3 से 5 तक np3 में डालें और x के सभी चाइल्ड संदर्भ को स्थिति 3 से 5 तक np3 में डालें नोड से सम्मिलित तत्वों को निकालें x np1 की पहली स्थिति में मध्य डालें और x को बाएं बच्चे के रूप में बनाएं और np3 को np1 के दाहिने बच्चे के रूप में np1 की तत्व संख्या बढ़ाएं, और इसे रूट के रूप में बनाएं। अन्य y :=स्थान i मध्य पर सबट्री :=y की स्थिति 2 से डेटा y से 0 की स्थिति 2 पर डेटा सेट करें y में डेटा की संख्या को 1 से कम करें y के सभी नोड्स को स्थिति 3 से 5 में डालें np3 np3 के एलिमेंट काउंट को बढ़ाता है, और y ऐड y चाइल्ड से i पोजीशन पर इंसर्ट किए गए एलिमेंट्स को हटाता है, और np3 को पोजिशन i+1 एंड ifEnd पर ऐड करता है। 
सम्मिलित करें(ए):
 

 इनपुट:एक तत्व a, जो डाला जाएगा।
 

 आउटपुट:अपडेट किया गया बी-ट्री
 
प्रारंभ x :=root यदि x शून्य है, तो रूट नोड बनाएं और x में रूट लें, यदि x लीफ नोड है, और इसमें 5 तत्व हैं, तो temp_node:=split_child(x, -1) x:=root i :=x डालने के लिए सही स्थिति का पता लगाएं:=स्थिति में x का बच्चा, जबकि x एक लीफ नोड नहीं है, क्या मैं:=स्थिति i पर x के बच्चे को सम्मिलित करने के लिए सही स्थिति का पता लगाएं, जिसमें 5 तत्व हैं, तो temp_node :=split_child (x, i) स्थिति x-> n की स्थिति में temp_node डेटा जोड़ें और x:=स्थिति में x का बच्चा मैं समाप्त होता हूं यदि समाप्त होता है यदि स्थिति x में x में जोड़ें x-> n xEnd के तत्वों को सॉर्ट करें 
 
उदाहरण कोड
 
#शामिल करेंनेमस्पेस std का उपयोग करके; struct BTreeNode{//B-tree int *data की एक नोड संरचना बनाएं; BTreeNode **child_ptr; बूल पत्ता; int n;}*रूट =NULL, *np =NULL, *x =NULL;BTreeNode * getNode(){ int i; एनपी =नया बीट्रीनोड; एनपी-> डेटा =नया इंट [5]; // पांच डेटा फ़ील्ड और 6 लिंक फ़ील्ड सेट करें np->child_ptr =नया BTreeNode *[6]; एनपी-> पत्ता =सच; // प्रारंभ में नोड एक पत्ता है np->n =0; के लिए (i =0; i <6; i++) {np->child_ptr[i] =NULL; // सभी पॉइंटर को अशक्त करने के लिए आरंभ करें} रिटर्न एनपी;} शून्य ट्रैवर्स (बीट्रीनोड * पी) {कोउट <<एंडल; इंट आई; के लिए (i =0; i n; i++) {// पूरे बी-पेड़ को पुनरावर्ती रूप से ट्रैवर्स करें यदि (p->लीफ ==असत्य) { ट्रैवर्स (p->child_ptr [i]); } cout <<"" < डेटा [i]; } अगर (पी-> पत्ता ==झूठा) { ट्रैवर्स (पी-> चाइल्ड_प्टर [i]); } cout< p[j]){ स्वैप (p[i], p[j]); } } }}int split_child(BTreeNode *x, int i){ // नोड को तीन नोड्स में विभाजित करें, एक रूट और दो बच्चे int मिड; BTreeNode *np1, *np3, *y; एनपी 3 =गेटनोड (); // np3 np3->leaf =true नामक एक नया लीफ नोड बनाएं; अगर (i ==-1) {मध्य =x-> डेटा [2]; // मध्य तत्व प्राप्त करें x-> डेटा [2] =0; एक्स-> एन--; एनपी 1 =गेटनोड (); np1->पत्ती =असत्य; एक्स-> पत्ता =सच; के लिए (int j =3; j <5; j++) {np3->डेटा [j - 3] =x-> डेटा [j]; np3->child_ptr[j - 3] =x->child_ptr[j]; एनपी 3-> एन ++; एक्स-> डेटा [जे] =0; एक्स-> एन--; } के लिए (int j =0; j <6; j++) { x->child_ptr[j] =NULL; } np1->डेटा [0] =मध्य; np1->child_ptr[np1->n] =x; np1->child_ptr[np1->n + 1] =np3; np1->n++; जड़ =np1; } और { y =x->child_ptr [i]; मध्य =y-> डेटा [2]; वाई-> डेटा [2] =0; वाई-> एन--; के लिए (int j =3; j <5; j++) {np3->data[j - 3] =y->data[j]; एनपी 3-> एन ++; वाई-> डेटा [जे] =0; वाई-> एन--; } x->child_ptr[i] =y; x->child_ptr[i + 1] =np3; } मध्य वापसी;} शून्य सम्मिलित करें (int a) {// BTree int i, tmp_node में डालें; एक्स =जड़; अगर (x ==NULL) {रूट =getNode (); एक्स =जड़; } और { if (x->leaf ==true &&x->n ==5) {// जब नोड एक लीफ नोड है और इसमें 5 डेटा tmp_node =split_child (x, -1) है; // नोड x =रूट को विभाजित करके एक नया स्तर बनाएं; के लिए (i =0; i <(x->n); i++) {if ((a> x->data[i]) &&(a data[i + 1])) {i++; टूटना; } और अगर (ए  डेटा [0]) {ब्रेक; } और {जारी रखें; } } x =x->child_ptr[i]; } और { जबकि (x-> पत्ता ==झूठा) {के लिए (i =0; i <(x->n); i++) { अगर ((a> x-> डेटा [i]) &&(a  डेटा [i + 1])) {i++; टूटना; } और अगर (ए  डेटा [0]) {ब्रेक; } और {जारी रखें; } } अगर ((x->child_ptr[i])->n ==5) {tmp_node =split_child(x, i); एक्स-> डेटा [एक्स-> एन] =tmp_node; एक्स-> एन ++; जारी रखें; } और {x =x->child_ptr[i]; } } } } x->डेटा[x->n] =a; सॉर्ट (एक्स-> डेटा, एक्स-> एन); एक्स-> एन ++;} इंट मेन () {इंट आई, एन, टी; cout<<"सम्मिलित किए जाने वाले तत्वों की संख्या दर्ज करें\n"; सिन>>एन; for(i =0; i >टी; सम्मिलित करें (टी); } cout<<"निर्मित पेड़ का ट्रैवर्सल\n"; ट्रैवर्स (रूट);}
 
आउटपुट
 
सम्मिलित किए जाने वाले तत्वों की संख्या दर्ज करें8तत्व दर्ज करें54तत्व दर्ज करें23तत्व दर्ज करें98तत्व दर्ज करें52तत्व दर्ज करें23तत्व दर्ज करें47तत्व दर्ज करें84निर्मित पेड़ के ट्रैवर्सल में प्रवेश करें10 23 23 475254 84 98