Is er een betere manier om de laagste gemeenschappelijke voorouder te vinden?

Question

Is er een betere manier om de laagste gemeenschappelijke voorouder te vinden?

stemmen

3

Ik weet dat soortgelijke vragen zijn al eerder gevraagd, maar ik denk dat mijn oplossing is veel eenvoudiger. Vooral in vergelijking met Wikipedia .

Gelieve te bewijzen dat ik ongelijk!

Als je een boom met knooppunten die de gegeven gegevensstructuur hebben:

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

Je zou een functie als dit te schrijven:

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;
}

Deze code is vrij eenvoudig en het slechtste geval is O (n), gemiddelde geval is het waarschijnlijk O (logn), vooral als de boom gebalanceerd (waarbij n het aantal knooppunten in de boom).

c binary-search-tree least-common-ancestor

De vraag is gesteld op 30/10/2010 om 03:26
bron van user theninjagreg

In andere talen...

3 antwoorden

stemmen

1

Nee, het spijt me. Maar je algoritme is niet goed. Neem de volgende BST:

you'r algoritme keert terug 10 de laagste gemeenschappelijke voorouder.

Zo zou je algoritme dat nemen, laten we zeggen, de linker knooppunt te schrijven en dan ga naar de moedermaatschappij en uit te voeren in-order op en dat controleren of juist was in de uitvoer van de in-order

antwoordde op 15/05/2013 om 23:02
bron van user tsvi

stemmen

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


}

antwoordde op 04/06/2013 om 08:52
bron van user user2450342

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

Uw Algoritme er goed uit ziet voor mij, in ieder geval kon ik niet denken aan iets beter. Merk op dat u niet de ouder pointer nodig hebben; in plaats daarvan kun je naar beneden gaan in de structuur vanaf de wortel, en vind het eerste knooppunt, waarvan de sleutel legt tussen de eerste twee toetsen.

Echter, het probleem heeft niets te maken met de ene Tarjan opgelost. In de eerste plaats van mening dat u binaire bomen en hij beschouwt n-ary bomen; maar dit is waarschijnlijk een detail. Wat nog belangrijker is, van mening dat u zoeken bomen, terwijl Tarjan vindt algemene bomen (geen bestelling op de toetsen). Uw probleem is veel eenvoudiger, omdat, afhankelijk van de toonsoort, kun je raden waar een bepaald knooppunt moet in de boom.