Gibt es eine bessere Art und Weise kleinste gemeinsame Vorfahren zu finden?

Question

Gibt es eine bessere Art und Weise kleinste gemeinsame Vorfahren zu finden?

stimmen

3

Ich weiß , dass ähnliche Fragen vor gefragt worden, aber ich denke , dass meine Lösung ist viel einfacher. Vor allem im Vergleich zu Wikipedia .

Bitte beweisen mich nicht falsch!

Wenn Sie einen Baum mit Knoten, die die gegebenen Datenstruktur:

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

Sie könnten eine Funktion wie folgt schreiben:

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

Dieser Code ist ziemlich einfach und schlimmste Fall ist O (n), die durchschnittliche Fall ist es wahrscheinlich O (log n), vor allem, wenn der Baum ausgeglichen (wobei n die Anzahl der Knoten im Baum ist).

c binary-search-tree least-common-ancestor

Veröffentlicht am 30/10/2010 um 03:26
quelle vom benutzer theninjagreg

In anderen Sprachen...

3 antworten

stimmen

1

Nein, es tut mir leid. Aber Ihr Algorithmus ist nicht gut. nehmen Sie die folgenden BST:

you'r Algorithmus 10 als die kleinste gemeinsame Vorfahre zurückzukehren.

So könnte man Algorithmus schreiben, die nehmen, sagen, den linken Knoten und als seine Eltern gehen und in Ordnung darauf laufen und dass die Überprüfung, ob direkt im Ausgang der in Ordnung war

Beantwortet am 15/05/2013 um 23:02
quelle vom benutzer tsvi

stimmen

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


}

Beantwortet am 04/06/2013 um 08:52
quelle vom benutzer user2450342

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

Ihr Algorithmus sieht okay für mich, zumindest habe ich nichts Besseres einfiel. Beachten Sie, dass Sie den übergeordneten Zeiger nicht brauchen; stattdessen können Sie den Baum ausgehend von der Wurzel nach unten gehen, und finden Sie den ersten Knoten, dessen Schlüssel liegt zwischen den beiden ersten Tasten.

Doch das Problem hat nichts zu tun mit dem einem Tarjan gelöst. Zunächst einmal betrachten Sie Binärbäumen und er hält n-äre Bäume; aber das ist wahrscheinlich ein Detail. Noch wichtiger ist, sollten Sie suchen Bäume, während Tarjan allgemeine Bäume (auf den Tasten keine Reihenfolge) hält. Ihr Problem ist viel einfacher, denn je nach dem Schlüssel, können Sie erraten, wo ein bestimmte Knoten im Baum sein.