एक बाइनरी ट्री में दो नोड्स के पहले सामान्य पूर्वज को खोजने के लिए एक एल्गोरिथ्म उत्पन्न करें।
समस्या समझने के लिए, हम यह समझने की कोशिश करेंगे कि बाइनरी ट्री क्या है। एक साधारण बाइनरी ट्री एक रूट नोड से शुरू होता है, जो फिर लेफ्ट और राइट सब-ट्री में विभाजित किया जाता है, उन नोडों को लेकर जिनमें डेटा संग्रहित होता है। आधार संरचना ट्री के लिए ऐसे नोड हैं जो एक उपयोगकर्ता द्वारा निर्धारित बहुमूल्य यूनिक कुंजी के साथ संदर्भ देने के लिए होते हैं। हम खोजना चाहते हैं कि दो नोड्स के पहले सामान्य पूर्वज कौन हैं। इस समस्या के लिए हम यह अनुमान लगा सकते हैं कि अगर नए नोड का कुंजी स्थान पहले से मौजूद है, तो हम जन्मांतर पर नोड का अनुसरण करें। यदि कुंजी एक संख्या है, तो आमतौर पर हम बाइनरी ट्री का कुंजी मूल्यों के साथ अनुसरण करने की कोशिश करेंगे। हम नीचे दिए गए Python आधारित प्रोग्राम में इस उपकरण का उपयोग करेंगे। 

```
def find_lca(root, n1, n2): 
    # Base Case 
    if root is None: 
        return None 
  
    # If both n1 and n2 are smaller than root, then LCA lies in left 
    if(root.key > n1 and root.key > n2): 
        return find_lca(root.left, n1, n2) 
  
    # If both n1 and n2 are greater than root, then LCA lies in right  
    if(root.key < n1 and root.key < n2): 
        return find_lca(root.right, n1, n2) 
  
    return root 
```

यहाँ फ़ंक्शन find_lca() थी जो pre-order ट्रावर्सल का उपयोग करती हुई, दो नोड्स n1 और n2 के पहले सामान्य पूर्वज को खोजती है। यह स्रोत नोड को ले जाता है और स्रोत का पहला सामान्य पूर्वज दो कुंजियों के लिए बटोर लेता है। यह फ़ंक्शन रुनटाइम में चलती है O(h) जहाँ h बाइनरी ट्री की ऊंचाई है।


इसके अलावा, हम X तथा Y के पहले सामान्य पूर्वज की विश्वसनीय और समझदार जानकारी से समृद्ध होते हैं तो हम मधुरता से अपने एगोरिदम को बदल सकते हैं जाति जो प्रश्न में कोई और विशिष्ट जानकारी नहीं है।