StackOverFlowException v BST algoritmu

Vaše logika je nesprávná. To nepůjde do zpětného falešného prohlášení.

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

Problém s kódu je to, že jste prochází špatně uzel do rekurzivních volání. Předpokládejme například, že váš prvek je menší než všechno ve stromu. Pak na první rekurzivní volání, budete hit toto prohlášení:

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

To znamená, že rekurzivně na kořen , ne levé dítě. Tedy na další iteraci, zjistíte, že tento prvek je menší než pravá dítěte kořene, a tak se budete znovu spustit přesně stejný příkaz rekurzivně volá opakovaně stejnou funkci, dokud vám dojdou místa zásobníku.

Chcete-li tento problém odstranit, měli byste změnit výše uvedený kód slouží ke čtení

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

To říká, že hledat v levém podstromu aktuálního uzlu, nikoli kořen sám. Stejně tak budete muset aktualizovat odpovídající případ pro pravou větev.

A konečně, to dokončit off, budete muset přidat základní případ vaší rekurzivní funkce, která zpracovává případ, kdy je strom null, a to buď proto, že jste odešel strom nebo strom byl prázdný začít. Nechám to jako cvičení. :-)

Nepotřebujete rekurzi. Stačí si jen opakovat, takže nemusíte Geta StackOverflow i když máte obrovský strom.

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