For å finne største element mindre enn K i en BST

Question

For å finne største element mindre enn K i en BST

stemmer

17

Gitt et binært søketre og et heltall K, vil jeg gjerne finne den største element mindre enn K.

I under treet,

for K = 13, result = 12
for K = 10, result = 8
for K = 1 (or) 2, result = -1

      10

  5       12

2   8   11  14

Jeg prøvde under logikk. Men er det noen bedre måte å gjøre dette?

int findNum(node* node, int K)
{
        if(node == NULL)
        {
                return -1;
        }
        else if(K <= node->data)
        {
                return findNum(node->left,K);
        }
        else if(K > node->data)
        {
                int t = findNum(node->right,K);
                return t > node->data ? t : node->data;
        }

        return -1;
}

c++c binary-search-tree

Publisert på 13/06/2011 klokken 18:22
kilden bruker joshu

På andre språk...

5 svar

stemmer

1

Jeg foreslår at du går gjennom koden i din lokale implementeringen av sett :: UPPER_BOUND for veiledning. Dette er ikke løsningen på din eksakte problemet, men svært nær.

Generelt i det virkelige liv, de fleste av disse problemene ikke trenger å løses i din egen kode. STL kan gjøre mange vanlige oppgaver for deg. Det er nyttig å vite hvordan du kan løse dem selvfølgelig, derav test.

Svarte 13/06/2011 kl. 18:29
kilden bruker Steve Townsend

stemmer

3

Jeg tror på å bruke standard bibliotek fasiliteter. Dermed bruker min løsning std::set. :-)

int largest_num_smaller_than(std::set<int> const& set, int num)
{
    std::set<int>::const_iterator lb(set.lower_bound(num));
    return lb == set.begin() ? -1 : *--lb;
}

Svarte 13/06/2011 kl. 18:33
kilden bruker Chris Jester-Young

stemmer

5

Jeg tror ideen her er å spille inn den siste noden etter som du flytter til høyre subtre. Derfor vil koden bli (har blitt oppdatert)

int findNum (Node *node, int K)
{
    Node* last_right_move = NULL;

    while (node)
    {
        if (K<=node->data)
            node = node->left;
        else
        {
            last_right_move = node;
            node = node->right;
        }
    }

    if (last_right_move)
        return last_right_move->data;
    else
        return NOT_FOUND;  // defined previously. (-1 may conflict with negative number)
}

Svarte 14/06/2011 kl. 02:06
kilden bruker badawi

stemmer

1

Hva det første svaret sa, og her er logikken bak hvorfor det ikke kan bli bedre enn O (log n). Du leter etter det største antallet mindre enn K. Dette er ganske nær å ringe BST-søk / får.

Selv om den opprinnelige algoritmen ser ganske bra, tror jeg dette vil være raskere:

    int findNum (node root, int K) {
        if(root == null) return -1;

        if(K > root.val) { 
           if(root.right != null) return findNum(root.right, K);               
           else return root.val; 
        }

        return findNum(root.left, K); //look in left subtree

    }

Svarte 27/07/2011 kl. 10:11
kilden bruker Arnab Datta

Jim Balter · Accepted Answer · 2011-06-13 19:25

Det er O (log n), som er den minste. Men du kan forbedre effektiviteten (som synes å være det viktigste disse intervjuere bryr seg om) og eliminere muligheten for stack overflow (tada!) Ved å eliminere halen rekursjon, snu dette til en loop. Også gjør koden ikke fungere hvis treet inneholder negative tall ... Hvis du mener ikke-negative heltall, bør du si det, men hvis intervjueren sa bare "heltall" så du trenger litt annen kode og en annen API. (Du kan beholde samme funksjon signatur, men returnerer K istedenfor -1 ved svikt.)

BTW, siden dette er et intervju spørsmålet, implementere det ved å kalle et bibliotek funksjon ville fortelle fleste intervjuere at du er en smartass eller mangler punktet eller ikke vet hvordan de skal løse det. Ikke rotet rundt med den slags ting, bare komme til å jobbe med det du vet intervjueren ønsker.

Her er en implementering:

// Return the greatest int < K in tree, or K if none.
int findNum (Node* tree, int K)
{
    int val = K;

    while( tree )
        if( tree->data >= K )
            tree = tree->left;
        else{
            val = tree->data; 
            tree = tree->right;
        }

    return val;
}