StackOverFlowException in BST algoritme

uw logica is onjuist. Het zal niet naar de terugkeer valse verklaring.

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

Het probleem met de code is dat je langs de verkeerde knooppunt in de recursieve gesprekken. Stel bijvoorbeeld dat uw element kleiner is dan alles in de boom. Dan op de eerste recursieve aanroep, zult u deze verklaring hit:

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

Dit betekent dat u recurse op de wortel , niet de linker kind. Dus op de volgende iteratie, zult u merken dat het element kleiner is dan het recht kind van de wortel, en dus je zult exact dezelfde instructie opnieuw uit te voeren, recursief bellen herhaaldelijk dezelfde functie totdat je geen stack ruimte meer.

Om dit te verhelpen, moet u de bovenstaande code te wijzigen om te lezen

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

Dit zegt te kijken in de linker deelboom van het huidige knooppunt, niet de wortel knooppunt zelf. Op dezelfde manier, moet u de desbetreffende zaak voor de rechter tak werken.

Tot slot, om deze af te maken, moet u een base case toe te voegen aan uw recursieve functie die de zaak behandelt waar de boom is null, omdat u uit de boom hebt gelopen of de boom leeg was om mee te beginnen. Ik zal dit te verlaten als een oefening. :-)

Je hebt geen recursie nodig. Je kunt gewoon herhalen, zodat je niet Geta StackOverflow, zelfs als je een enorme boom.

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