अपने बाइनरी ट्री की संरचना करें। प्रत्येक बाइनरी ट्री को एक संरचना की आवश्यकता होगी, भले ही उसमें केवल एक चर हो। एक नाम चुनें, फिर इसे बनाने के लिए typedef का उपयोग करें: typedef struct student_data STUDENT_DATA;
संरचना को परिभाषित कीजिए। एक ही संरचना में दो पॉइंटर्स शामिल करें: स्ट्रक्चर स्टूडेंट_डेटा {इंट स्टूडेंट_आईडी; इंट स्टूडेंट_ग्रेड; STUDENT_DATA बाएं, अधिकार;};
इस डेटा संरचना के लिए एक पॉइंटर आवंटित करें, इसे पेड़ के सिर होने के लिए इसे न्यूल में प्रारंभ करें: STUDENT_DATA *students = NULL;
डेटा संरचना में दो अस्थायी पॉइंटर्स आवंटित करें: STUDENT_DATA नया विद्यार्थी, cur_student;
एक नया तत्व बनाने के लिए malloc () का उपयोग करें, हमेशा एक त्रुटि की जाँच करें: यदि ((new_student = malloc (sizeof (STUDENT_DATA))) == NULL) {abort (); }
नए तत्व के क्षेत्रों को आबाद करें। इसके बाएँ और दाएँ फ़ील्ड को NULL पर सेट करें: new_student->student_ID = newID; new_student->student_size = newsize; new_student->बाएं = न्यूल; new_student->right = NULL;
सिर चर पर विचार करें। यदि हेड वेरिएबल NULL है, तो यह ट्री में जोड़ा गया पहला तत्व है, इसलिए हेड वेरिएबल को इसे इंगित करने के लिए सेट करें, और आपका काम हो गया: if (!students) {छात्र = new_student; वापसी; }
यदि नया मान और वर्तमान मान समान हैं, तो डुप्लिकेट प्रविष्टि को हैंडल करें: if (newID == cur_student->student_ID) { abort (); }
असमान मूल्यों से निपटें। यदि नया मान वर्तमान मान से कम है, तो नया तत्व बाईं ओर जाता है। अगर बाईं ओर कुछ नहीं है तो इसे तुरंत जोड़ें। अन्यथा, ट्रैवर्स लेफ्ट और लूप: if (newID
वही काम दाईं ओर करें, अन्यथा: } और { अगर (cur_student->right == NULL) {cur_student->right = newtudent; वापसी 1; } cur_student = cur_student->right; }}
डेटा संरचना की ओर इशारा करते हुए एक अस्थायी चर बनाएँ: STUDENT_DATA *cur_student;
तत्वों के माध्यम से लूप, वांछित मूल्य की जांच: जबकि (cur_student) {if (cur_student->student_ID == 15) {वापसी cur_student->student_grad; }
शाखा बाएँ या दाएँ, और लूप, यदि यह नहीं मिला है: if (cur_student->student_ID <15) {cur_student = cur_student->right; } और {cur_student = cur_student->बाएं; }
देखें कि क्या लूप समाप्त होता है। यदि ऐसा होता है, तो इसका अर्थ है कि आपको वह वस्तु कभी नहीं मिली: }वापसी 0;
जब आपका प्रोग्राम समाप्त हो जाता है तो बाइनरी ट्री को हटा दें, क्योंकि सभी ऑपरेटिंग सिस्टम इसे स्वचालित रूप से संभाल नहीं पाएंगे। यह एक पुनरावर्ती फ़ंक्शन का उपयोग करके सबसे अच्छा किया जाता है: शून्य डीललोकेट_बिनरी_ट्री (STUDENT_DATA * ट्री) {
बाएँ और दाएँ उपप्रकारों को पुनरावर्ती रूप से हटाएँ: Deallocate_binary_tree (पेड़-> बाएँ); डीललोकेट_बाइनरी_ट्री (पेड़-> दाएं);
रिकर्सन का उपयोग करके बाइनरी पेड़ों को खोजना और जोड़ना भी किया जा सकता है। इसे लिखना और बनाए रखना बहुत आसान होगा, लेकिन जब तक आपको इसकी आदत नहीं हो जाती, तब तक इसे समझना थोड़ा कठिन होगा। एक बाइनरी ट्री बनाना आम है जिसमें केवल दूसरी सी डेटा संरचना में पॉइंटर्स होते हैं, अक्सर एक सरणी या लिंक्ड सूची, जहां वास्तविक डेटा रहता है। प्रत्येक बाइनरी ट्री सूची डेटा के एकल फ़ील्ड को शीघ्रता से खोजने के लिए एक अनुक्रमणिका है।
बाइनरी ट्री से हटाना C में एक बहुत ही जटिल एल्गोरिथम है, लेकिन बाइनरी ट्री के कई उपयोगों में, तत्वों को कभी भी हटाया नहीं जाता है।
