Het vinden van de k-de kleinste waarde in een BST

Question

Het vinden van de k-de kleinste waarde in een BST

stemmen

0

Hier is wat ik de k kleinste waarde in een binaire zoekboom vinden:

struct treeNode 
{
   int data;
   struct treeNode *left, *right:
};

int rank(stuct treeNode* ptr, int k)
{
   if(node == NULL)
    return root; 

   while(ptr->left != NULL) {
     ptr = ptr->left;
     return rank(ptr->left)
   }
}

Dit is natuurlijk niet juist. Zonder het verstrekken van de oplossing, kan iemand me in de juiste richting over hoe ik dit kan oplossen? Ik heb problemen met het uitzoeken hoe ik de k kleinste element in een BST kon vinden.

c binary-search-tree

De vraag is gesteld op 03/05/2011 om 02:17
bron van user kachilous

In andere talen...

3 antwoorden

stemmen

0

Dit zou moeten werken:

int rank(struct treeNode* n,int k,int* chk)
    {
    if(!n) return -1;
    int _chk = 0;
    if(!chk) chk = &_chk;

    int t = rank(n->left,k,chk);
    if(t>=0) return t;

    if(++*chk > k) return n->data;

    int t = rank(n->right,k,chk);
    if(t>=0) return t;
    return -1;
    }

noemen als rank(root,k,0)

antwoordde op 03/05/2011 om 02:35
bron van user David X

stemmen

1

Als u de grootte van elk van de substructuren kan dit uitvoerbaar zijn zonder de gegevens te lezen in een array (of op andere wijze de boom doorkruisen) en tellen. Als u niet de grootte informatie bij de hand weet te houden, heb je een helper functie moet de grootte te berekenen.

Het basisidee, erachter te komen wat is de index van het huidige knooppunt. Als het minder dan k is, moet je naar links substructuur doorzoeken. Als deze groter is dan k, zoeken de juiste compensatie van de knooppunten rekenen vanaf de linkerzijde en de huidige. Merk op dat dit is in wezen hetzelfde als het zoeken door middel van een regelmatige BST, behalve deze keer zijn we op zoek in de index, geen gegevens. Enkele pseudocode:

if size of left subtree is equal to k:
    // the current node is kth
    return data of current node
else if size of left subtree is greater than k:
    // the kth node is on the left
    repeat on the left subtree
else if size of left subtree is less than k:
    // the kth node is on the right
    reduce k by the size of the left subtree + 1 // need to find the (k')th node on the right subtree
    repeat on the right subtree

Om dit te illustreren, overweeg deze boom met de gemarkeerde indices (zelfs niet zorgen te maken over de gegevens zoals het is niet belangrijk in de zoektocht):

        3
      /   \
     2     6
    /     / \
   0     4   7
    \     \
     1     5

Stel dat we willen naar de 2e (k = 2) vinden.
Vanaf 3, de grootte van de linker deelboom 3.
Het is dan k dus naar links substructuur.
De grootte van de linker deelboom 2.
k is 2, zodat de huidige knoop moet 2 zijn.

Stel dat we willen naar de 4e (k = 4) te vinden.
Vanaf 3, de grootte van de linker deelboom 3.
Het is dan l passen zodat de nieuwe k aan 0 (k'= 4 - (3 + 1)) en naar rechts deelboom.
Vanaf 6, de grootte van de linker deelboom 2.
Het is dan k (0) zodanig naar links substructuur.
De grootte van de linker deelboom 0.
k' is 0, zodat het huidige knooppunt moet 4 zijn.

Je krijgt het idee.

antwoordde op 03/05/2011 om 02:45
bron van user Jeff Mercado

Arrix · Accepted Answer · 2011-05-03 02:47

stemmen

5

De auteur van de vraag accepteerde dit antwoord als de beste.

Een BST is een gesorteerde binaire boom, een in-orde traversal (linker deelboom, huidige knoop, rechter deelboom) zal knooppunt gesorteerde waarden verkregen. Om de k kleinste knooppunt vinden, gewoon doen een in-orde traversal met een teller. De teller begint vanaf 0, wanneer een knooppunt wordt doorlopen, verhogen met één, wanneer het k bereikt het knooppunt de kde kleinste.

antwoordde op 03/05/2011 om 02:47
bron van user Arrix