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