java - 简单二叉树的 Add 方法出现莫名其妙的问题

Question

我的二叉树看起来与我的类 Material 非常接近，但是当我打印到控制台或检查 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 将对象引用传递给方法。如果您更改引用，则不会传播回调用方法。如果您更改引用所指的内容这将被传播回来。

例如

// 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。