एक BST में सबसे बड़ा तत्व कश्मीर की तुलना में छोटे जानने के लिए

Question

एक BST में सबसे बड़ा तत्व कश्मीर की तुलना में छोटे जानने के लिए

वोट

17

एक द्विआधारी खोज वृक्ष और एक पूर्णांक कश्मीर को देखते हुए, मैं लालकृष्ण से भी कम समय सबसे बड़ा तत्व प्राप्त करना चाहते हैं

नीचे ट्री में,

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

      10

  5       12

2   8   11  14

मैं नीचे तर्क की कोशिश की। लेकिन वहाँ यह करने के लिए किसी भी बेहतर तरीका है?

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

13/06/2011 को 19:22
का स्रोत उपयोगकर्ता joshu

अन्य भाषाओं में...

5 जवाब

वोट

1

मेरा सुझाव है कि आप अपने स्थानीय कार्यान्वयन में कोड के माध्यम से चलना सेट :: UPPER_BOUND मार्गदर्शन के लिए। यह अपने सटीक समस्या का हल है, लेकिन बहुत करीब नहीं है।

वास्तविक जीवन में सामान्य तौर पर, इन समस्याओं के सबसे अपने खुद के कोड में हल किया जा की जरूरत नहीं है। एसटीएल आप के लिए कई सामान्य कार्यों कर सकते हैं। यह उन्हें कैसे निश्चित रूप से हल करने के लिए है, इसलिए परीक्षण पता करने के लिए उपयोगी है।

13/06/2011 को 19:29
का स्रोत उपयोगकर्ता Steve Townsend

वोट

3

मैं मानक पुस्तकालय सुविधाओं का उपयोग करने में विश्वास करते हैं। इस प्रकार, मेरी समाधान का उपयोग करता 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;
}

13/06/2011 को 19:33
का स्रोत उपयोगकर्ता Chris Jester-Young

वोट

5

मुझे लगता है कि विचार यहां पिछले नोड जिसके बाद आप सही सबट्री में ले जाने के रिकॉर्ड करने के लिए है। इसलिए, कोड (अद्यतन किया गया है) हो जाएगा

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

14/06/2011 को 03:06
का स्रोत उपयोगकर्ता badawi

वोट

1

क्या पहले उत्तर कहा, और यहाँ के पीछे कारण है कि यह हे (लॉग एन) की तुलना में बेहतर नहीं मिल सकता है तर्क है। आप सबसे बड़ा कम संख्या लालकृष्ण से यह काफी बुला BST-खोज / पाने के करीब है के लिए देख रहे हैं।

हालांकि अपने मूल एल्गोरिथ्म काफी अच्छा लग रहा है, मुझे लगता है कि यह तेजी से होगा:

    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

    }

27/07/2011 को 11:11
का स्रोत उपयोगकर्ता Arnab Datta

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

यही कारण है कि हे (लॉग एन) है, जो कम से कम है। हालांकि, अगर आप दक्षता में सुधार कर सकते हैं और पूंछ प्रत्यावर्तन को नष्ट करने, एक पाश में इस बदल कर ढेर अतिप्रवाह की संभावना को दूर (टाडा!) (जो मुख्य बात ये साक्षात्कारकर्ताओं के बारे में परवाह हो रहा है)। इसके अलावा, अपने कोड काम नहीं करता है, तो पेड़ ऋणात्मक संख्याओं में शामिल है ... यदि आप मतलब गैर नकारात्मक integers, तो आप ऐसा कहना चाहिए, लेकिन अगर साक्षात्कारकर्ता सिर्फ इतना कहा "पूर्णांक" तो आप थोड़ा अलग कोड और एक अलग एपीआई की जरूरत है। (आप एक ही समारोह हस्ताक्षर रखते हैं लेकिन कश्मीर लौट -1 के बजाय विफलता पर कर सकते हैं।)

Btw, के बाद से इस एक साक्षात्कार सवाल, एक पुस्तकालय समारोह बुला सबसे साक्षात्कारकर्ताओं है कि आप एक smartass हैं या बात को अनदेखा कर रहे हैं या कि यह कैसे हल करने के लिए पता नहीं है कहते थे द्वारा लागू है। गड़बड़ नहीं आसपास बात की इस प्रकार की के साथ क्या, बस तुम क्या जानते साक्षात्कारकर्ता चाहता है पर काम कर रहा करने के लिए मिलता है।

यहाँ एक कार्यान्वयन है:

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