Finnes det en bedre måte å finne minste felles stamfar?

Question

Finnes det en bedre måte å finne minste felles stamfar?

stemmer

3

Jeg vet at lignende spørsmål har blitt spurt før, men jeg tror min løsning er langt enklere. Spesielt i forhold til Wikipedia .

Vennligst bevise meg feil!

Hvis du har et tre med noder som har gitt datastruktur:

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

Du kan skrive en funksjon som dette:

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

Denne koden er ganske enkel og verste tilfellet er O (n), gjennomsnittlig tilfelle det er sannsynligvis O (LOGN), spesielt hvis treet er balansert (hvor n er antallet noder i treet).

c binary-search-tree least-common-ancestor

Publisert på 30/10/2010 klokken 02:26
kilden bruker theninjagreg

På andre språk...

3 svar

stemmer

1

Nei jeg beklager. Men din algoritmen er ikke bra. ta følgende BST:

du'r algoritme vil returnere 10 som det laveste felles stamfar.

Dermed kan du skrive algoritme som tar, sier venstre node og enn å gå til sine overordnede og kjøre i for på den og at sjekken hvis retten var i produksjon av in-ordre

Svarte 15/05/2013 kl. 22:02
kilden bruker tsvi

stemmer

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


}

Svarte 04/06/2013 kl. 07:52
kilden bruker user2450342

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

Din Algoritmen ser greit for meg, i hvert fall kunne jeg ikke tenke meg noe bedre. Merk at du ikke trenger den overordnede pekeren; i stedet kan du gå ned treet fra roten, og finne den første noden som nøkkelen ligger mellom de to første tastene.

Men problemet har ingenting å gjøre med en Tarjan løst. Først av alt, anser du binære trær, og han anser n-ær trær; men dette er trolig en detalj. Enda viktigere, anser du søke trær, mens Tarjan vurderer generelle trær (ingen bestilling på tastene). Ditt problem er mye enklere, fordi, avhengig av nøkkelen, kan du gjette hvor en bestemt node må være i treet.