StackOverflowException nell'algoritmo BST

la logica non è corretta. Non andrà alla falsa dichiarazione di ritorno.

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

Il problema con il vostro codice è che si sta passando il nodo sbagliato nelle chiamate ricorsive. Supponiamo, per esempio, che il vostro elemento è più piccolo di tutto l'albero. Poi sulla prima chiamata ricorsiva, ti ha colpito questa affermazione:

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

Ciò significa che è ricorsiva sulla radice , non il figlio sinistro. Così sulla prossima iterazione, troverete che l'elemento è più piccolo del figlio destro della radice, e quindi dovrete eseguire di nuovo la stessa dichiarazione precisa, chiamando ricorsivamente la stessa funzione più volte fino a quando si esaurisce lo spazio di stack.

Per risolvere questo problema, è necessario modificare il codice qui sopra per leggere

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

Questo dice di guardare nel sottoalbero sinistro del nodo corrente, non il nodo radice stessa. Allo stesso modo, è necessario aggiornare il caso corrispondente per il ramo di destra.

Infine, per concludere questa via, è necessario aggiungere un caso base alla funzione ricorsiva che gestisce il caso in cui l'albero è null, o perché hai camminato fuori l'albero o l'albero era vuota per cominciare. Lascio questo come un esercizio. :-)

Non hai bisogno di ricorsione. Si può solo scorrere in modo da non Geta StackOverflow anche se si dispone di un enorme albero.

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