Ahhoz, hogy megtalálja legnagyobb eleme kisebb, mint a K a BST

Question

Ahhoz, hogy megtalálja legnagyobb eleme kisebb, mint a K a BST

szavazat

17

Adott egy bináris keresési fa és egy K egész, szeretnék, hogy megtalálják a legnagyobb elem kisebb, mint K.

Az alábbi fa,

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

      10

  5       12

2   8   11  14

Próbáltam a lenti logika. De van-e jobb módja ennek?

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

A kérdést 13/06/2011 19:22
a forrás felhasználó joshu

Más nyelveken...

5 válasz

szavazat

1

Azt javaslom, hogy menjen végig a kódot a helyi végrehajtása set :: UPPER_BOUND útmutatást. Ez nem az a megoldás, hogy a pontos probléma, de nagyon közel van.

Általában a valós életben, a legtöbb ilyen problémák nem kell megoldani a saját kódját. STL tehetünk sok közös feladatokat az Ön számára. Ez hasznos tudni, hogyan kell megoldani őket természetesen így a teszt.

Válaszolt 13/06/2011 19:29
a forrás felhasználó Steve Townsend

szavazat

3

Hiszek a standard könyvtár. Vagyis, az oldatot használ 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;
}

Válaszolt 13/06/2011 19:33
a forrás felhasználó Chris Jester-Young

szavazat

5

Azt hiszem, az ötlet az, hogy rögzítse az utolsó csomópont, amely után mozgatni a jobb részfa. Ezért a kód (frissült)

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

Válaszolt 14/06/2011 03:06
a forrás felhasználó badawi

szavazat

1

Mi az első válasz az említett, és itt van a logikája, hogy miért nem tud jobb, mint O (log n). Ön keres a legtöbb kisebb K. Ez nagyon közel van a hívó BST-kereső / kap.

Bár az eredeti algoritmust úgy néz ki, elég jó, azt hiszem, ez gyorsabb lenne:

    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

    }

Válaszolt 27/07/2011 11:11
a forrás felhasználó Arnab Datta

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

Ez O (log n), ami a minimális. Azonban, ha a hatékonyság növelése (ami úgy tűnik, hogy a legfontosabb dolog, ezek a kérdezők érdekli), és megszünteti a lehetőségét veremtúlcsordulás (tada!) Kiküszöbölésével farok rekurzió fordult ez egy hurkot. Továbbá, a kód nem működik, ha a fa tartalmaz negatív számok ... ha érted , nem negatív egész számok, meg kell mondani, de ha a kérdező csak azt mondta: „egész”, akkor meg kell kissé eltérő kódot, egy másik API. (Lehet tartani ugyanazt a funkciót aláírást, de visszatér helyett a K -1 fel hiba.)

BTW, mivel ez egy interjú kérdés, azt végrehajtó hívja a könyvtár funkció megmondja a legtöbb kérdező, hogy te egy okostojás vagy hiányzik a lényeg, vagy nem tudja, hogyan kell megoldani. Ne szórakozz körül az ilyesmit, csak kap a dolgozó, hogy mit tud a kérdező akar.

Itt van egy végrehajtási:

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