कार्य दिए गए बाइनरी ट्री के दाएं नोड्स को प्रिंट करना है। सबसे पहले उपयोगकर्ता बाइनरी ट्री बनाने के लिए डेटा डालेगा और फिर बने ट्री का राइट व्यू प्रिंट करेगा।
उपरोक्त आरेख 10, 42, 93, 14, 35, 96, 57 और 88 नोड्स के साथ बने बाइनरी ट्री को दिखाता है। इन नोड्स में से जो ट्री के दाईं ओर स्थित हैं उन्हें चुना जाता है और स्क्रीन पर प्रदर्शित किया जाता है। उदाहरण के लिए, 10, 93, 57 और 88 बाइनरी ट्री के दायें सबसे नोड्स हैं।
उदाहरण
इनपुट: 10 42 93 14 35 96 57 88 आउटपुट: 10 93 57 88
प्रत्येक नोड के साथ दो पॉइंटर जुड़े होते हैं यानी लेफ्ट और राइट। इस प्रश्न के अनुसार, प्रोग्राम को केवल दाएं नोड्स को ट्रैवर्स करना होगा। इसलिए नोड के लेफ्ट चाइल्ड के बारे में चिंता करने की कोई आवश्यकता नहीं है।
राइट व्यू उन सभी नोड्स को संग्रहीत करता है जो अपने लेवल के अंतिम नोड्स हैं। इसलिए, हम केवल रिकर्सिव दृष्टिकोण का उपयोग करके नोड्स को इस तरह से संग्रहीत और एक्सेस कर सकते हैं कि राइट सबट्री को लेफ्ट सबट्री से पहले ट्रैवर्स किया जाए। जब भी प्रोग्राम उस नोड का पता लगाता है जिसका लेवल पिछले नोड के लेवल से अधिक होता है तो पिछले नोड को प्रदर्शित किया जाता है क्योंकि यह अपने लेवल का अंतिम नोड होगा।
एल्गोरिदम
शुरुआत
चरण 1 → नोड वेरिएबल को संरचना टाइप का बनाएं
int data घोषित करें
*left, *right का उपयोग करके नोड टाइप का पॉइंटर घोषित करें
चरण 2 → पैरामीटर के रूप में item के साथ नोड डालने का फंक्शन बनाएं
malloc का उपयोग करके temp वेरिएबल नोड का बनाएं
temp->data = item सेट करें
temp->left = temp->right = NULL सेट करें
temp रिटर्न करें
चरण 3 → void right_view(struct node *root, int level, int *end_level) फंक्शन घोषित करें
यदि root = NULL तो रिटर्न
यदि *end_level < level तो
root->data प्रिंट करें
*end_level = level सेट करें
right_view(root->right, level+1, end_level) कॉल करें
right_view(root->left, level+1, end_level) कॉल करें
चरण 4 → void right(struct node *root) फंक्शन घोषित करें
int level = 0 सेट करें
right_view(root, 1, &level) कॉल करें
चरण 5 → main() में
struct node *root = New(10) का उपयोग करके ट्री नोड्स के लिए मान पास करें
right(root) कॉल करें
समाप्त
उदाहरण
#include <stdio.h>
#include <stdlib.h>
struct node {
int data;
struct node *left, *right;
};
struct node *New(int item) {
struct node *temp = (struct node *)malloc(sizeof(struct node));
temp->data = item;
temp->left = temp->right = NULL;
return temp;
}
void right_view(struct node *root, int level, int *end_level) {
if (root == NULL) return;
if (*end_level < level) {
printf("%d\t", root->data);
*end_level = level;
}
right_view(root->right, level+1, end_level);
right_view(root->left, level+1, end_level);
}
void right(struct node *root) {
int level = 0;
right_view(root, 1, &level);
}
int main() {
printf("right view of a binary tree is : ");
struct node *root = New(10);
root->left = New(42);
root->right = New(93);
root->left->left = New(14);
root->left->right = New(35);
root->right->left = New(96);
root->right->right = New(57);
root->right->left->right = New(88);
right(root);
return 0;
}
आउटपुट
यदि हम उपरोक्त प्रोग्राम चलाते हैं तो यह निम्नलिखित आउटपुट उत्पन्न करेगा।
right view of a binary tree is : 10 93 57 88
