कार्य में उपयोगकर्ता द्वारा निर्दिष्ट दिए गए लेवल k पर बाइनरी ट्री के लीफ नोड्स प्रिंट करना शामिल है।
लीफ नोड्स अंतिम नोड्स होते हैं जिनके लेफ्ट और राइट पॉइंटर NULL होते हैं जिसका अर्थ है कि वह विशेष नोड पैरेंट नोड नहीं है।
उदाहरण
इनपुट: 11 22 33 66 44 88 77 आउटपुट: 88 77
यहां, k ट्री का लेवल दर्शाता है जिसे प्रिंट करने की आवश्यकता है। यहां उपयोग किया गया दृष्टिकोण हर नोड को ट्रैवर्स करना और जांचना है कि क्या नोड के पास कोई पॉइंटर है। भले ही एक पॉइंटर हो यानी लेफ्ट या राइट या दोनों तो वह विशेष नोड लीफ नोड नहीं हो सकता।
लेवल ऑर्डर तकनीक का उपयोग करके प्रत्येक नोड को रिकर्सिवली ट्रैवर्स करना जिसमें नोड्स को लेवल वाइज ट्रैवर्स किया जाता है: लेफ्ट → रूट → राइट।
एल्गोरिदम
शुरुआत
चरण 1 → नोड वेरिएबल को संरचना टाइप का बनाएं
int data घोषित करें
*left, *right का उपयोग करके नोड टाइप का पॉइंटर घोषित करें
चरण 2 → पैरामीटर के रूप में new_data के साथ नोड डालने का फंक्शन बनाएं
malloc का उपयोग करके temp वेरिएबल नोड का बनाएं
temp->data = new_data सेट करें
temp->left = temp->right = NULL सेट करें
temp रिटर्न करें
चरण 3 → void leaf(struct node* root, int level) फंक्शन घोषित करें
यदि root = NULL तो एग्जिट
यदि level = 1 तो
यदि root->left == NULL && root->right == NULL तो root->data प्रिंट करें
अन्यथा यदि level > 1 तो
leaf(root->left, level - 1) कॉल करें
leaf(root->right, level - 1) कॉल करें
चरण 4 → main() में
level = 4 सेट करें
struct node* root = New(1) का उपयोग करके मान पास करें
leaf(root, level) कॉल करें
समाप्त
उदाहरण
#include <stdio.h>
#include <stdlib.h>
// नोड की संरचना परिभाषित
struct node {
struct node* left;
struct node* right;
int data;
};
// नया नोड बनाने की संरचना
struct node* New(int data) {
struct node* temp = (struct node*)malloc(sizeof(struct node));
temp->data = data;
temp->left = NULL;
temp->right = NULL;
return temp;
}
// लीफ नोड ढूंढने का फंक्शन
void leaf(struct node* root, int level) {
if (root == NULL)
return;
if (level == 1) {
if (root->left == NULL && root->right == NULL)
printf("%d\n", root->data);
} else if (level > 1) {
leaf(root->left, level - 1);
leaf(root->right, level - 1);
}
}
int main() {
printf("leaf nodes are: ");
struct node* root = New(11);
root->left = New(22);
root->right = New(33);
root->left->left = New(66);
root->right->right = New(44);
root->left->left->left = New(88);
root->left->left->right = New(77);
int level = 4;
leaf(root, level);
return 0;
}
आउटपुट
यदि हम उपरोक्त प्रोग्राम चलाते हैं तो यह निम्नलिखित आउटपुट उत्पन्न करेगा।
leaf nodes are: 88 77
