BST एल्गोरिथ्म में StackOverFlowException

अपने तर्क सही नहीं है। यह वापसी झूठा बयान करने के लिए नहीं जाना होगा।

private Boolean contains(Node<T> node, T item)
    {
      if (item.CompareTo(root.Data) == 0)
      {
        return true;//return 0 if found
      }
      else///if 0 <> 
      {
        if (item.CompareTo(root.Data) > 0)  //if 0<
        {
          //root = node.Left;
          Node<T> left = root.Left;
          return(contains(root, item));
        }
        else  //if 0>
        {
          if (item.CompareTo(root.Data) < 0) if // 0>
          {
            //root = node.Right;
            Node<T> right = root.Right;
            return(contains(root, item));
          }
          else  // this will be not executed ever
          {
            return false;//return 1 if not found
          }
        }        
      }
    }

अपने कोड के साथ समस्या यह है कि आप पुनरावर्ती कॉल में गलत नोड गुजर रहे हैं। मान लीजिए, उदाहरण के लिए, जो आपके तत्व पेड़ में सब कुछ से छोटा है। तब पहली पुनरावर्ती कॉल पर, आप इस कथन को हिट होगी:

Node<T> left = root.Left;
return(contains(root, item));

इसका मतलब यह है कि आप पर recurse जड़ , नहीं छोड़ दिया बच्चे को। अगले चरण पर इस प्रकार, आप उस तत्व जड़ का सही बच्चे की तुलना में छोटा होता है मिल जाएगा, और इसलिए आप ठीक उसी बयान फिर से अमल होगा, रिकर्सिवली एक ही समारोह बुला बार बार जब तक आप ढेर स्थान समाप्त हो गया।

इसे ठीक करने के लिए, आप को पढ़ने के लिए ऊपर दिए गए कोड बदलना चाहिए

Node<T> left = node.Left;
return(contains(left, item));

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

अंत में, इस बंद समाप्त करने के लिए, आप अपने पुनरावर्ती क्रिया उस मामले संभालती है जहां पेड़ है करने के लिए एक आधार के मामले जोड़ने की आवश्यकता होगी null, क्योंकि या तो आप पेड़ चला गया गया है या पेड़ के साथ शुरू करने के लिए खाली था,। मैं एक व्यायाम के रूप में इस छोड़ देंगे। :-)

आप प्रत्यावर्तन जरूरत नहीं है। तुम बस पुनरावृति ताकि आप StackOverflow Geta नहीं है, भले ही आप एक विशाल पेड़ हो सकता है।

public Boolean Contains(T item) {
    Node<T> currentNode = root;

    while(currentNode != null) { // Or whatever you use to signal that there is no node.
        switch(item.CompareTo(currentNode.Data)) {
            case -1:
                currentNode = currentNode.Right;
                break;
            case 1:
                currentNode = currentNode.Left;
                break;
            default: // case 0
                return true;
        }
    }
    return false;
 }