मान लीजिए कि हमारे पास एक बाइनरी ट्री है जिसमें रूट नोड है और उसका बायां बच्चा और दायां बच्चा है। कार्य पेड़ के लीफ नोड्स का कुल योग ज्ञात करना है जो उसके मूल नोड पर छोड़े गए हैं।
उदाहरण के लिए
इनपुट-1:
<मजबूत> 
आउटपुट:
15
स्पष्टीकरण: दिए गए इनपुट बाइनरी ट्री में, सभी लेफ्ट लीफ नोड्स का योग 9+4+2 =15 है। तो, आउटपुट 15 है।
इस समस्या को हल करने का तरीका
हमारे पास एक बाइनरी ट्री है और कार्य सभी लीफ नोड्स का योग ज्ञात करना है जो इसके माता-पिता के लिए छोड़े गए हैं।
इस समस्या को हल करने के लिए पुनरावर्ती दृष्टिकोण यह जांचना है कि रूट नोड का बायां नोड खाली है या नहीं। यदि यह खाली है, तो इसके बाएँ नोड के लिए योग की गणना करें और दाएँ नोड के लिए पुनरावर्ती योग ज्ञात करें। इस प्रकार, प्रत्येक नोड के लिए, हम पुनरावर्ती रूप से जाँच करेंगे और उसका योग ज्ञात करेंगे।
- एक बाइनरी ट्री लें जिसमें रूट नोड्स हों और उसके बाएं बच्चे के साथ-साथ दायां बच्चा इनपुट के रूप में।
- एक पूर्णांक फ़ंक्शन leftLeafSum(treenode*root) रूट नोड को इनपुट के रूप में लेता है और सभी लीफ नोड्स का योग देता है जो उसके पैरेंट को छोड़ दिया जाता है।
- यदि रूट नोड खाली है या NULL है, तो 'शून्य' लौटाएं अन्यथा रूट नोड के बाएं नोड की जांच करें।
- यदि रूट नोड के बाएं नोड में कोई संतान नहीं है, तो दाएं नोड की दोबारा जांच करें।
- बाएं बच्चे और दाएं बच्चे के लिए राशि दोबारा लौटाएं।
उदाहरण
#include<bits/stdc++.h>
using namespace std;
struct treenode {
int data;
treenode * left;
treenode * right;
};
struct treenode * createNode(int d) {
struct treenode * root = new treenode;
root -> data = d;
root -> left = NULL;
root -> right = NULL;
return root;
}
int leftLeafSum(treenode * root) {
if (root == NULL) {
return 0;
}
if (root -> left and!root -> left -> left and!root -> left -> right) {
return root -> left -> data + leftLeafSum(root -> right);
}
return leftLeafSum(root -> left) + leftLeafSum(root -> right);
}
int main() {
struct treenode * root = NULL;
root = createNode(4);
root -> left = createNode(2);
root -> right = createNode(2);
root -> left -> right = createNode(7);
root -> left -> left = createNode(5);
root -> right -> left = createNode(5);
root -> right -> right = createNode(7);
int sum = leftLeafSum(root);
cout << sum << endl;
return 0;
} उपरोक्त कोड को चलाने से आउटपुट इस प्रकार उत्पन्न होगा,
आउटपुट
10
स्पष्टीकरण: बाएं नोड्स में लीफ नोड्स 5 और 5 हैं जो उनके माता-पिता के लिए छोड़ दिए गए हैं, इस प्रकार सभी लीफ नोड का योग =10 है।