一个简单二叉树的添加方法的无法解释的问题

Question

我的二叉树看起来非常接近我的类材料，但是当我打印到控制台或检查contains()时，我所做的任何添加都没有注册。

我对static没有很好的理解，调试器给了我一个关于对非静态变量overallRoot进行静态引用的提示，但是在eclipse中所有编译都没有错误或警告。

public class BSTSimpleSet<E extends Comparable<E>> implements SimpleSet<E> {
private GTNode<E> overallRoot;
private int size;
public static void main(String[] args) {
    BSTSimpleSet<Integer> main = new BSTSimpleSet<Integer>(2);
    main.toString();
    main.add(3);
    main.toString();
    main.add(4);
    main.toString();
    main.add(5);
    main.toString();
    System.out.print(main.contains(3));
}
public BSTSimpleSet() {
    size = 0;
}
public BSTSimpleSet(E input) {
    overallRoot = new GTNode<E>(input);
    size = 1;
}
public boolean add(E e) {
    return add(e, overallRoot);
}
private boolean add(E e, GTNode<E> root) {
    if (root == null) {
        root = new GTNode<E>(e);
        size++;       
        return true;
    } else {
        int compare = e.compareTo(root.data);
        if (compare == 0) {
            return false;
        } else if (compare < 0) {
            return add(e, root.left);
        } else {
            return add(e, root.right);
        }
    }
}
public void clear() {
    overallRoot = null;
}
public boolean contains(E e) {
    return contains(e, overallRoot);
}
private boolean contains(E e, GTNode<E> root) {
    if (root == null) {
        return false;
    } else {
        int compare = e.compareTo(root.data);
        if (compare == 0) {
            return true;
        } else if (compare < 0) {
            return contains(e, root.left);
        } else {
            return contains(e, root.right);
        }
    }
}
public boolean isEmpty() {
    if (overallRoot == null) {
        return false;
    } else {
        return true;
    }
}
public int size() {
    return size;
}
public String toString() {
    this.toString(overallRoot, 0);
    return null;
}
private void toString(GTNode<E> root, int level) {
    if (root != null) {
        for (int i = 0; i < level; i++) {
            System.out.print("     ");
        }
        System.out.println(root.data);
        toString(root.left, level + 1);
        toString(root.right, level + 1);            
    } else {
        for (int i = 0; i < level; i++) {
            System.out.print("     ");
        }
        System.out.println("_");
    }
}
private static class GTNode<E extends Comparable<E>> {
    public E data;
    public GTNode<E> left;
    public GTNode<E> right;
    public GTNode(E input) {
        this(input, null, null);
    }
    public GTNode(E input, GTNode<E> lNode, GTNode<E> rNode) {
        data = input;
        left = lNode;
        right = rNode;
    }
}

}

Answer 1

这段代码什么也没做。

private boolean add(E e, GTNode<E> root) {
    if (root == null) {
        root = new GTNode<E>(e);
        size++;       
        return true;
    }
 ...

Java将对象引用传递给方法。如果您更改引用，则不会被传播回调用方法。如果你改变了Reference引用的内容这将被传播回来。

如

// arrays behave the same way so using them to illustrate.
public void callMethods(){
    int[] array = new int[1];
    array[0] = 0;
    doesNotChange(array);    
    System.out.println(array[0]);// will print 0
    doesAChange(array);    
    System.out.println(array[0]);// will print 1
}
public void doesNotChange(int[] myArray){
    myArray = new int[1];
    myArray[0] = 1;
}
public void doesAChange(int[] myArray){
    myArray[0] = 1;
}

为了避免这类事情，我建议总是将方法参数设置为final。

Answer 2

GTNode类不应该是静态的。静态类是只有静态方法的类，这意味着它们不需要实例化。这方面的典型例子是java.lang.Math类:您不需要调用Math m = new Math(); m.cos();之类的东西来获得余弦，只需调用Math.cos()即可。由于要创建GTNode类的多个实例，所以请将其设置为非静态的，这样就可以了。