StackOverFlowException a BST algoritmus

a logika hibás. Ez nem fog menni a visszatérő hamis állítás.

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

A probléma a kódot, hogy te halad a rossz csomópontot a rekurzív hívások. Tegyük fel például, hogy az elem kisebb, mint mindent a fán. Aztán az első rekurzív hívás, akkor nyomja ezt a kijelentést:

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

Ez azt jelenti, hogy recurse a gyökér , nem a bal gyerek. Így a következő iteráció, rájössz, hogy az elem kisebb, mint a jobb gyermek a gyökér, és így lesz végre pontosan ugyanazt a nyilatkozatot ismét rekurzív hívás az azonos funkciójú többször, amíg elfogy a verem helyet.

Ennek javításához meg kell változtatni a fenti kódot olvasni

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

Ez azt mondja, hogy nézd a bal részfa az aktuális csomópont, nem a gyökér is. Hasonlóképpen, akkor frissítenie kell a megfelelő esetben a megfelelő ágat.

Végül, hogy befejezze ezt le, akkor meg kell adni a kiinduló helyzet, a rekurzív függvény, amely kezeli az esetben, ha a fa null, vagy azért, mert már elindult a fa vagy a fa üres volt, hogy kezdődik. El fogom hagyni ezt az edzés során. :-)

Nem kell a rekurziót. Tudod csak hajtogat, így nem Geta StackOverflow akkor is, ha van egy hatalmas fa.

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