My setter is not setting

Question

So I am trying to implement BST (Binary Search Tree) I have made an add method which adds TreeNodes to an tree[TreeNode] array

Here is the TreeNode class where I'm trying to set the parent as well as the left and right nodes, I inspected with a debugger and I'm not sure why but it is not setting the Parent var and also it only add one or the other in the leftChild and rightChild fields.

The setter in question is this one

//set parent
public void setParent(TreeNode t)
{
    this.parent = t.parent;
}

I cant understand when i call it from the PAS43DEPQ class it does not set properly.

class TreeNode implements Comparable<TreeNode>
{
    private Integer value;
    private TreeNode leftChild;
    private TreeNode rightChild;
    private TreeNode parent;

    //constructors
    public TreeNode(){}
    public TreeNode(Integer v){this.value  = v;}
    public TreeNode(TreeNode t){
        this.value = t.value;
        this.parent = t.parent;
        this.leftChild = t.leftChild;
        this.rightChild = t.rightChild;
    }
    public TreeNode (Comparable c){this.value = (int) c;}

    //set parent
    public void setParent(TreeNode t)
    {
        this.parent = t.parent;
    }
    //get parent
    public TreeNode getParent()
    {
        return this.parent;
    }
    //get value
    public int getValue(){return value;}
    //set value
    public void setValue(Integer i){ this.value = i;}
    //get left node
    public TreeNode getLeftChild(){return leftChild;}
    //get right node
    public TreeNode getRightChild(){return rightChild;}
    //set left child
    public void setLeftChild(TreeNode t) {this.leftChild = t;}
    //set right child
    public void setRightChild(TreeNode t) {this.rightChild = t;}

    public TreeNode find(int n)
    {
        //this statement runs if the current node is == the value being searched.
        if(this.value == n)
            return this;
        //this returns values left of the root then performs a recursive call if not found
        if(value < this.value && leftChild != null)
            return leftChild.find(n);
        //this does the same as above except looks on the right side of the root
        if(rightChild != null)
            return rightChild.find(n);

        //this returns if value is not found
        return null;
    }

    @Override
    public int compareTo(TreeNode o)
    {

        if (this.value == o.value)
        {
            return 0;// if value equal
        }
        if (this.value > o.value) //if value greater
        {
             return 1;
        }
        if (this.value < o.value)
        {
            return -1;   //if value less
        }
        return 99;
    }
}

Here is the class where I add from:

public class PAS43DEPQ implements DEPQ
{
    private TreeNode[] tree = new TreeNode[100];
    int index = 0;

    @Override
    public Comparable inspectLeast() {
        return null;
    }

    @Override
    public Comparable inspectMost() {
        return null;
    }

    /*
    right: (2 * n) + 2
    left: (2 * n) + 1
    parent: (1 - n) / 2
     */

    public int right()
    {
        return (2 * index) + 2;
    }

    public int left()
    {
        return (2 * index) + 1;
    }

    public int parent()
    {
        return Math.round((index  - 1) / 2);
    }

    @Override
    public void add(Comparable c)
    {
        // Root node
        if (tree[0] == null) {
            tree[0] = new TreeNode(c);
            return;
        }

        //this while loop is for tree traversal
        while(tree[index] != null) {
            if( c.compareTo(tree[index].getValue()) == 0) {
                index += right() - index;
                continue;
            }

            if( c.compareTo(tree[index].getValue()) > 0) {

                index += right() - index;
                continue;
            }

            if( c.compareTo(tree[index].getValue()) < 0) {
                index += left() - index;
                continue;
            }

        }

        //this part is for place the new node
        if(tree[index] == null) {
            tree[index] = new TreeNode(c);
            tree[index].setParent(tree[parent()]);

            if( c.compareTo(tree[index].getValue()) == 0)
                tree[parent()].setRightChild(tree[index]);

            if( c.compareTo(tree[index].getValue()) > 0)
                tree[parent()].setRightChild(tree[index]);

            if( c.compareTo(tree[index].getValue()) < 0)
                tree[parent()].setLeftChild(tree[index]);


            index = 0;
        }

        return;
    }

    @Override
    public Comparable getLeast() {
        return null;
    }

    @Override
    public Comparable getMost() {
        return null;
    }

    @Override
    public boolean isEmpty() {
        return (tree[0] == null) ? true : false;
    }

    @Override
    public int size() {
        return tree.length;
    }
}

I cant seam to work out why the parent isnt being set the the the line "tree[index].setParent(tree[parent()])"

is being called? any ides on why this is happening?

Answer 1

The set method should be like this

//set parent
public void setParent(TreeNode t)
{
    this.parent = t;
}

This method will make TreeNode t as the parent of the Current Node referenced by this.

The statement which you are using sets parent of TreeNode t as the parent of the current node.