在BST的左侧插入正确的子级，反之亦然

Question

I'm having a little bit of difficulty with my insert method for this homework assignment. I have most of it done, but for some reason whenever my program is supposed to insert a node as a right child on the left side of the tree it just inserts it as a left child.

I kind of do my comparison in a weird way (signs should be reversed for a lot of them, but it worked like that for some reason) so please bear with me if you have difficulty in reading it.

I know that this is a horrible way to implement a binary search tree, and I would never ever do it in the real world, but it's homework and thus -- I have no choice.

Any and all help is appreciated, as always. Thank you!

Edit: I know where the problem is now. It's within the searchFor() method. Instead of the node's rightful parent, it makes the parent the root of the tree (in this case the parent of the node is always "cup".)

now that that's out of the way, can anyone offer up a solution?

Edit2: Took some of the extra stuff out that I don't think is relevant to the problem. I'm pretty sure I've narrowed it down to the searchFor() method. Whenever I call to return the parent of the current node, it will return the root of the tree ("cup.") I think that's why I'm having my problems, since it inserts based on that.

Thanks for all the help so far, I really appreciate it.

public class BinarySearchTree //implements Comparator
{
private Comparator<Object> dataComparator;
private LinkedListWithTwoLinks tree;

public static void main (String[] args)
{
    BinarySearchTree bst;
    Object hold;
    String[] words = {"cup", "shaker", "cord", "key", "addressbook", "date", "address", "cupcake",
    "card", "tape", "page", "day", "key", "days", "dayt"};

    bst = new BinarySearchTree(new AlphabeticComparator());
    System.out.println("[1]: original tree");
    for(int i=0; i<words.length; i++) if (!bst.insert(words[i])) { System.out.println(">>>>>>>>>>>>> " + words[i] + " is already in tree"); }
    bst.inOrder();

    }

    public static class AlphabeticComparator implements Comparator <Object>
    {
    public int compare(Object x, Object y)
    {
    if ( x == y ) return 0;
    if ( x == null) return -1;
    if ( y == null) return 1;
    return (x.toString().compareTo(y.toString()));
    }
    }


    public static class LastCharacterComparator implements Comparator <Object>
    {
    public int compare(Object x, Object y)
    {
    String xs;
    String ys;

    if ( x == y ) return 0;
    if ( x == null ) return -1;
    if ( y == null) return 1;

    xs = x.toString();
    ys = y.toString();

    if ( xs.length() == 0) return -1;
    if ( ys.length() == 0) return 1;

    return (xs.charAt(xs.length()-1) - ys.charAt(ys.length()-1));
    }
}

public BinarySearchTree(Comparator<Object> y)
{
    dataComparator = y;
    this.tree = new LinkedListWithTwoLinks();
}

private int compare(BinarySearchTreeElementInterface s, Object data)
{
    return this.dataComparator.compare(s, data);
}


public boolean insert(Object data)
{
    boolean success;
    BinarySearchTreeElementInterface current;
    BinarySearchTreeElementInterface parent;
    current = getRoot();
    parent = null;
    success = false;
    if (current == null)
     {
        getTree().insert(data);
        return true;
     }

    else 
    {
        SearchResult insert;
        insert = searchFor(data);
        //if (data == "shaker") {System.out.println(insert.resultOfCompare); }
        while (current != null)
        {
            if (insert.insertAsLeftChild())
            {
                //if (data == "card") {System.out.println("IN RIGHT");}
                //System.out.println("IN LEFT");
                parent = current;
                current = current.getLeftChild();
            }

            else if (insert.insertAsRightChild())
            {
                //if (data == "card") {System.out.println("IN RIGHT");}
                parent = current;
                current = current.getRightChild();
            }

        }

        if (insert.insertAsLeftChild())
        {
            //parent.setLeftChild(insert.getParentOfLocation()); //insert.getParentOfLocation()
            //System.out.println(data);
            getTree().insertUsingPrior(parent, data);
            //System.out.println(insert.getParentOfLocation()+" bye left");
        //  System.out.println(insert.getLocation()+" hi");
            success = true;
        }

        else if (insert.insertAsRightChild())
        {
            //parent.setRightChild(insert.getParentOfLocation());
            //System.out.println(data);
            getTree().insertUsingNext(parent, data);
            //System.out.println(insert.getParentOfLocation()+" bye right");
        //  System.out.println(insert.getLocation());
            success = true;
        }

        else {success = false;}
        /*
        figures out if it should be inserted as a left or right child
        then call insert using prior/next
        }*/
    }

    return success;
}


private SearchResult searchFor(Object data)
{
    /*returns either to node containing the data or the parent of the node of which the data would be a child of*/
    if (getTree() == null) {throw new ListEmptyException("Tree is empty!");}
    BinarySearchTreeElementInterface currentLocation;
    BinarySearchTreeElementInterface parent;
    SearchResult destination;
    parent = getRoot();
    currentLocation = parent;


    while (currentLocation != null)
    {
        if (currentLocation.getData() == data)
        {
            return new SearchResult(parent, currentLocation, compare(currentLocation, data));
        }

        if (compare(currentLocation, data) < 0)
        {
            //System.out.println("IN LEFT");
            parent = currentLocation;
            currentLocation = currentLocation.getLeftChild();
        }

        else if (compare(currentLocation, data) > 0)
        {
            //System.out.println("IN RIGHT");
            parent = currentLocation;
            currentLocation = currentLocation.getRightChild();
        }


    }


    destination = new SearchResult(parent, currentLocation, compare(parent, data));
    //System.out.println(destination.resultOfCompare);
    return destination;
    /*
     * use nothing but BSTEIs
    */
}

public void inOrder()
{
    inOrder(getRoot());
}

public void inOrder(BinarySearchTreeElementInterface BSTroot)
{

    //System.out.println(BSTroot.getRightChild());
    if (BSTroot != null)
    {
        inOrder(BSTroot.getLeftChild());
        System.out.println(BSTroot.getData());
        inOrder(BSTroot.getRightChild());
    }

    /*if (BSTroot.getLeftChild() != null)
    {

    }
    System.out.println(BSTroot.getData());
    if (BSTroot.getRightChild() != null)
    {
        inOrder(BSTroot.getRightChild());
        //System.out.println(BSTroot.getData());
    }
    System.out.println(BSTroot.getData());*/
}

public int size()
{
    return tree.size();
}
/*SEARCH RESULT CLASS-----------------------------------------------------------------------------------------*/
    public class SearchResult
    {
        BinarySearchTreeElementInterface location;
        BinarySearchTreeElementInterface parentOfLocation;
        int resultOfCompare;

        public SearchResult(BinarySearchTreeElementInterface parent, BinarySearchTreeElementInterface locate, int comp)
        {
            this.parentOfLocation = parent;
            this.location = locate;
            this.resultOfCompare = comp;

        }

        public BinarySearchTreeElementInterface getLocation()
        {
            return this.location;
        }

        public BinarySearchTreeElementInterface getParentOfLocation()
        {
            return this.parentOfLocation;
        }

        public boolean insertAsLeftChild()
        {
            if (resultOfCompare > 0) {return true;}
            else {return false;}
        }

        public boolean insertAsRightChild()
        {
            if (resultOfCompare < 0) {return true;}
            else {return false;}
        }

        public boolean locationIsLeftOfParent()
        {
            return this.location == parentOfLocation.getLeftChild();
        }

        public boolean locationisRightOfParent()
        {
            return this.location == parentOfLocation.getRightChild();
        }

        public boolean wasSearchSuccessful()
        {   
            return this.parentOfLocation == this.location;
        }

        public void setLocation(BinarySearchTreeElementInterface newLocation)
        {
            this.location = newLocation;
        }

        public void setLocationOfParent(BinarySearchTreeElementInterface newParentLocation)
        {
            this.parentOfLocation = newParentLocation;
        }
    }

}

Answer 1

compare(x, y) method of BinarySearchTree is wrong. It compares a node to a data with a comparator made to compare data against data. Change 'Object' to 'String' and it will not compile while your sample data are strings.

This should fix it:

private int compare(BinarySearchTreeElementInterface s, Object data)
{
    return this.dataComparator.compare(s.getData(), data);
}

Answer 2

In your SearchResult class, do you have the way it determines a left or right insert swapped?

public boolean insertAsLeftChild()
{
    if (resultOfCompare > 0) {return true;}
    else {return false;}
}

If the compare is greater than 0, it should be interested as a right child, correct?