वहाँ सबसे कम आम पूर्वज खोजने के लिए एक बेहतर तरीका है?

Question

वहाँ सबसे कम आम पूर्वज खोजने के लिए एक बेहतर तरीका है?

वोट

3

मैं जानता हूँ कि इसी तरह के सवाल से पहले कहा गया है, लेकिन मुझे लगता है कि मेरी समाधान बहुत आसान है। विशेष रूप से की तुलना में विकिपीडिया ।

कृपया मुझे गलत साबित!

आप नोड्स दिए गए डेटा संरचना है कि के साथ एक पेड़ है, तो:

struct node
{
    node * left;
    node * right;
    node * parent;
    int key;
}

आप इस प्रकार का समारोह लिख सकते हैं:

node* LCA(node* m, node* n)
{
    // determine which of the nodes is the leftmost
    node* left = null;
    node* right = null;
    if (m->key < n->key)
    {
        left = m;
        right = n;
    }
    else
    {
        left = n;
        right = m;
    }
    // start at the leftmost of the two nodes,
    // keep moving up the tree until the parent is greater than the right key
    while (left->parent && left->parent->key < right->key)
    {
        left = left->parent;
    }
    return left;
}

इस कोड को बिल्कुल स्पष्ट है और सबसे ज्यादा मामले हे (एन), औसत मामला यह शायद ओ (logn), खासकर अगर पेड़ संतुलित किया जाता है (जहां n पेड़ में नोड्स की संख्या है) है।

c binary-search-tree least-common-ancestor

30/10/2010 को 03:26
का स्रोत उपयोगकर्ता theninjagreg

अन्य भाषाओं में...

3 जवाब

वोट

1

नहीं मुझे माफ़ कर दो। लेकिन अपने एल्गोरिथ्म अच्छा नहीं है। निम्नलिखित BST ले:

you'r एल्गोरिथ्म सबसे कम आम पूर्वज के रूप में 10 वापस आ जाएगी।

इस प्रकार, आप एल्गोरिथ्म है कि ले, कहते हैं, बाईं नोड लिख सकता है और की तुलना में अपने माता-पिता के पास जाकर इन-आदेश उस पर और कहा कि जांच चलाने अगर सही में आदेश के उत्पादन में किया गया था

15/05/2013 को 23:02
का स्रोत उपयोगकर्ता tsvi

वोट

1

Node* getAncestor( Node* root, Node* node1 , Node* node2 )
{
    if( root->val > node1->val && root->val > node2->val )
        getAncestor( root->left , node1 , node2 );
    //recursive call with left subtree

    if( root->val < node1->val && root->val < node2->val )
        getAncestor( root->right , node1 , node2 );
    //recursive call with right subtree

    return root ;
    //returning the root node as ancestor

    //initial call is made with the tree's root node
    //node1 and node2 are nodes whose ancestor is to be located


}

04/06/2013 को 08:52
का स्रोत उपयोगकर्ता user2450342

ksson · Accepted Answer · 2010-11-01 20:18

आपका एल्गोरिथ्म मेरे लिए ठीक लग रहा है, कम से कम मैं कुछ भी बेहतर के बारे में सोच नहीं सकता था। ध्यान दें कि आप माता-पिता सूचक जरूरत नहीं है, इसके बजाय आप पेड़ जड़ से शुरू नीचे जाना, और प्रथम नोड जिसका कुंजी दो प्रारंभिक कुंजी के बीच देता है पा सकते हैं।

हालांकि, आपकी समस्या के साथ एक Tarjan हल लेना देना नहीं है। सबसे पहले, आप द्विआधारी पेड़ पर विचार और वह n-ary पेड़ पर विचार करता है; लेकिन यह शायद एक विस्तार है। इससे भी महत्वपूर्ण बात, आप खोज के पेड़ पर विचार करें, Tarjan सामान्य पेड़ (कुंजी पर कोई आदेश देने) पर ध्यान देता है। आपकी समस्या, क्योंकि कुंजी के आधार पर आप जहां एक निश्चित मोड ट्री में हो गया है अनुमान लगा सकते हैं बहुत सरल है,।