0

我的二叉树看起来非常接近我的课程材料，但是当我打印到控制台或检查 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;
    }
}

}

4

2 回答 2

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。

于 2013-06-04T21:55:10.307 回答
0

GTNode 类不应该是静态的。静态类是只有静态方法的类，这意味着它们不必被实例化。典型的例子是 java.lang.Math 类：你不需要调用类似Math m = new Math(); m.cos();的东西来获取余弦，你只需调用Math.cos(). 由于您正在创建 GTNode 类的多个实例，因此将其设置为非静态的，您应该会很好。

于 2013-06-04T21:48:00.957 回答