Java BST的迭代方法

这些是我的领域：

public class BSTSet <E> extends AbstractSet <E> {

    // Data fields
    private BSTNode root;
    private int count = 0;
    private Comparator<E> comp;   // default comparator

    /** Private class for the nodes.
     *  Has public fields so methods in BSTSet can access fields directly. 
     */
    private class BSTNode {

        // Data fields

        public E value;
        public BSTNode left = null;
        public BSTNode right = null;

        // Constructor

        public BSTNode(E v) {
            value = v;
        }

        //creates a method called contains so that i can call it later on for my find method
        public boolean contains(Object item) {
            return contains(item);//root.value.equals(item);
        }

        public int height() {
            return height();
        }

    }
    // Constructors - can either use a default comparator or provide one
    public BSTSet() {
        comp = new ComparableComparator();      // Declared below
    }

    public BSTSet(Comparator <E> c) {
        comp = c;
    }
}

公共类BSTSet扩展了抽象集{
//数据字段
私有节点根；
私有整数计数=0；
专用比较器comp；//默认比较器
/**节点的私有类。
*具有公共字段，因此BSTSet中的方法可以直接访问字段。
*/
私有类节点{
//数据字段
公共价值观；
公共节点left=null；
公共节点权限=null；
//建造师
公共节点（EV）{
值=v；
}
//创建一个名为contains的方法，以便稍后我可以为find方法调用它
公共布尔包含（对象项）{
return包含（item）；//root.value.equals（item）；
}
公共整数高度（）{
返回高度（）；
}
}
//构造函数-可以使用默认比较器，也可以提供一个
公共数据集（）{
comp=新的ComparableComparator（）；//声明如下
}
公共数据集（比较器c）{
comp=c；
}
}

这就是我想要完成的：

private class BSTSetIterator implements Iterator<E> {

    private Stack<BSTNode> stack = new Stack<BSTNode>();
    private BSTNode current = root;

    public BSTSetIterator(BSTNode root) {

         return new BSTSetIterator();

    }

    public boolean hasNext() {

        boolean hasNext = false;
        hasNext = !stack.isEmpty() || current != null;
        return hasNext;

    }

    public E next() {

        BSTNode next = null;

        while (current != null) {
            stack.push(current);
            current = current.left;
        }
        next = stack.pop();
        current = next.right;

        return next;

    }

    public void remove() {
        throw new UnsupportedOperationException();
    }
}
// Comparator for comparable 

private class ComparableComparator implements Comparator<E> {
    public int compare(E ob1, E ob2) {
        return ((Comparable)ob1).compareTo(ob2);
    }
}

私有类BSTSetIterator实现迭代器{
私有堆栈=新堆栈（）；
私有节点当前=根节点；
公共BSTSetIterator（BSTNode根节点）{
返回新的BSTSetIterator（）；
}
公共布尔hasNext（）{
布尔hasNext=false；
hasNext=！stack.isEmpty（）| | current！=null；
返回hasNext；
}
公共教育{
bstnodenext=null；
while（当前！=null）{
堆栈推送（当前）；
current=current.left；
}
next=stack.pop（）；
当前=下一个。右；
下一步返回；
}
公共空间删除（）{
抛出新的UnsupportedOperationException（）；
}
}
//比较法
私有类ComparableComparator实现Comparator{
公共整数比较（E ob1，E ob2）{
收益率（（可比）ob1），与（可比）ob2；
}
}

到目前为止，代码在第

行返回新的BSTSetIterator（）时失败

和

返回下一步。对于
return next
，它表示返回的数据类型错误。我将如何修复这些方法，以便可以使用堆栈遍历BST

BSTSetIterator();

这不起作用，因为构造函数需要根，而您没有传递该参数。如果您有一个名为“tree”的BSTSet对象，并且您想要创建一个新的迭代器，那么您应该通过以下方式创建迭代器：

BSTSetIterator iterator = new BSTSetIterator(tree.getRoot());

public BSTSetIterator(BSTNode root)
{
    this.current = root;
}

但是，在BSTSet类中没有getter，并且根是私有的。别担心，该问题的解决方案是在BSTSetIterator类中创建一个公共getter，如下所示：

public BSTNode getRoot()
{
    return this.root;
}

构造函数不返回值，这是不正确的：

 public BSTSetIterator(BSTNode root) {
         return new BSTSetIterator();
    }

相反，请用以下方式书写您的构造函数：

BSTSetIterator iterator = new BSTSetIterator(tree.getRoot());

public BSTSetIterator(BSTNode root)
{
    this.current = root;
}

此外，此定义是不正确的，因为root用户无法访问：

private BSTNode current = root;

您应该改为：

private BSTNode current;

至于你的另一个问题

BSTNode next = null;

表示名为“next”的变量为BSTNode类型

public E next()

意味着名为next的方法是E类型的。由于E和BSTNode不相同，您的报税表：

return next;

这是不正确的。我可以给你更多的帮助，但我意识到你现在正在学习这种语言，最好让你自己探索一下技术和编程，因为这样你会变得更快。“给一个人一条鱼，你就可以喂他一天。教一个人如何钓鱼，你就可以喂他一辈子。”
把你的类改成
私有类怎么样？BSSetIterator实现了迭代器