inOrderIterator method cannot be applied to BinaryTreeNode<T>

Question

Working on an InOrderIterator traversal method. I understand how to do this recursively but I keep getting this complier error.

inOrderIterator() in LinkedBinarySearchTree<T> cannot be applied to (BinaryTreeNode<T>)

Im not sure why I can't apply this method to that object. Any ideas? Heres my method so far

public ArrayList<T> inOrderIterator()
{
  ArrayList<T> myArr = new ArrayList<T>();
  BinaryTreeNode<T> currentNode = this.root;
  if(currentNode != null)
  {
     inOrderIterator(currentNode.getLeftChild());
     myArr.add(currentNode.getElement());
     inOrderIterator(currentNode.getRightChild());
  }

  return myArr;
}

LinkedBinarySearchTree.java

import jss2.exceptions.EmptyCollectionException;
import jss2.exceptions.ElementNotFoundException;
import java.util.ArrayList;


public class LinkedBinarySearchTree<T extends Comparable<T>> 
{

private T elem;
BinaryTreeNode<T> root;

public LinkedBinarySearchTree (T element)  
{
  elem = element;
  root = null;
}

public LinkedBinarySearchTree ()  
{
  root = null;
}

public void addToTree (T element)  
{

  //Check if root is null
  if(root == null)
  {
     root.getElement().equals(element);
  }
  else
  {
     addToTreeHelper(root, element);
  }
}

 public void addToTreeHelper(BinaryTreeNode<T> node, T target)
{
  BinaryTreeNode<T> child;
  BinaryTreeNode<T> targetNode = new BinaryTreeNode<T>(target);

  if(target.compareTo(node.getElement()) == -1)
  {
     child = node.getLeftChild();

     if(child == null)
     {
        node.setLeftChild(targetNode);
     }

     else
     {
        addToTreeHelper(node.getLeftChild(), target);
     }
  }

  else if(target.compareTo(node.getElement()) >= 0)
  {
     child = node.getRightChild();

     if(child == null)
     {
        node.setRightChild(targetNode);
     }

     else
     {
        addToTreeHelper(node.getRightChild(), target);
     }
  }
}


  //remove Element

  public void removeElement(T target) throws Exception
  {
  BinaryTreeNode<T> node;

  if(root.getElement() == null)
  {
     throw new EmptyCollectionException("tree is empty");
  }

  else if(target.compareTo(root.getElement()) == 0)
  {
     root = getReplacement(root);

  }

  else
  {
     node = removeElemHelper(root, target);
     if(node ==  null)
     {
        throw new ElementNotFoundException ("not found "+target.toString());
     }
  }
  }

  //remove element helper

 public BinaryTreeNode<T> removeElemHelper(BinaryTreeNode<T> node, T target)
 {

  BinaryTreeNode<T> result, child, replacement;
  result = null;
  if(node != null)
  {
     if(target.compareTo(node.getElement()) == -1)
     {
        child = node.getLeftChild();
        if(child != null && target.compareTo(child.getElement()) == 0)
        {
           result = child;
           replacement = getReplacement(child);
           if(replacement == null)
           {
              node.setLeftChild(null);
           }
           else
           {
              node.setLeftChild(replacement);
           }
        }

        else
        {
           result = removeElemHelper(child, target);
        }
     }

     //
     else if(target.compareTo(node.getElement()) == 1)
     {
        child = node.getRightChild();
        if(child != null && target.compareTo(child.getElement()) == 0)
        {
           result = child;
           replacement = getReplacement(child);
           if(replacement == null)
           {
              node.setRightChild(null);
           }
           else
           {
              node.setRightChild(replacement);
           }
        }

        else
        {
           result = removeElemHelper(child, target);
        }
     }

  } 

  return result; 
}

 //replacement
 public BinaryTreeNode<T> getReplacement(BinaryTreeNode<T> node)
 {
  BinaryTreeNode<T> result,leftChild, rightChild;
  leftChild = node.getLeftChild();
  rightChild = node.getRightChild();

  if(node.getLeftChild() == null && node.getRightChild() == null)
   {
     result = null;
   }

   else if(node.getLeftChild() == null && node.getRightChild() != null)
   {
     result = node.getRightChild();
   }

   else if(node.getLeftChild() != null && node.getRightChild() == null)
   {
     result = node.getLeftChild();
   }

   else
   {
     result = findInorderSucessor(rightChild);
     result.setLeftChild(leftChild);
     result.setRightChild(rightChild);
   }

   return result;

}

 //findInorderSucessor
 private BinaryTreeNode<T> findInorderSucessor(BinaryTreeNode<T> node)
 {
   BinaryTreeNode<T> child = node.getLeftChild();

  if(child == node)
  {
     return node;
  }
  else if(child.getLeftChild() == null)
  {
     child.setRightChild(node.getLeftChild());
  }

  return findInorderSucessor(child);
 }

 public ArrayList<T> inOrderIterator()
 {
  ArrayList<T> myArr = new ArrayList<T>();
  BinaryTreeNode<T> currentNode = this.root;
  if(currentNode != null)
  {
     inOrderIterator(currentNode.getLeftChild());
     myArr.add(currentNode.getElement());
     inOrderIterator(currentNode.getRightChild());
  }

  return myArr;
 }


}

Answer 1

Look at your method declaration:

public ArrayList<T> inOrderIterator()

It doesn't have any parameters. But look how you're trying to invoke it:

inOrderIterator(currentNode.getRightChild());

... you're specifying an argument. There's no method which is applicable for that call.

I suspect you want to overload the method to have a private method accepting a node and a List<T> (the one you're building up), and then make your public method call that. For example:

public List<T> inOrderIterator() {
    List<T> list = new ArrayList<T>();
    inOrderIterator(list, this.root);
    return list;
}

private void inOrderIterator(List<T> list, BinaryTreeNode<T> current) {
    if (current == null) {
        return;
    }
    inOrderIterator(current.getLeftChild());
    list.add(current);
    inOrderIterator(current.getRightChild());  
}