Java 自定义树集类，如何编写迭代器

我正在尝试创建自己的二叉搜索树。但是我想不出任何方法来实现一个具有hasNext（），next（）的工作迭代器。 我想到了遍历二叉搜索树的唯一方法是通过递归。但是，如果我试图使用next，那么当next再次被调用并返回值时，它会恢复，那么我怎么可能保存递归调用呢？ 还有别的办法吗

import java.util.Iterator;

public class TreeWordSet implements WordSetInterface {
    private BST root = null;

    private class BST {
        Word value;
        BST left = null;
        BST right = null;

        BST(Word word) {
            value = word;
        }

        void add(Word newWord) {
            if (newWord.compareTo(value) < 0) {
                if(left == null) {
                    left = new BST(newWord);
                } else {
                    left.add(newWord);
                }
            } else if (newWord.compareTo(value) > 0) {
                if (right == null) {
                    right = new BST(newWord);
                } else {
                    right.add(newWord);
                }
            }
        }
    }

    @Override
    public void add(Word word) {
        if (root == null) {
            root = new BST(word);
        } else {
            root.add(word);
        }
    }

    @Override
    public boolean contains(Word word) {
        return false;
    }

    @Override
    public int size() {
        return 0;
    }

    private class TreeWordSetIterator implements Iterator<Word> {

        @Override
        public boolean hasNext() {
            return false;
        }

        @Override
        public Word next() {
            return null;
        }
    }

    @Override
    public Iterator<Word> iterator() {
        return new TreeWordSetIterator();
    }

}

import java.util.Iterator；
公共类TreeWordSet实现了WordSetInterface{
私有BST根=空；
私人班{
词值；
BST left=null；
BST-right=null；
英国理工学士（Word）{
值=字；
}
无效添加（单词新词）{
if（newWord.compareTo（值）<0）{
if（left==null）{
左=新BST（新词）；
}否则{
左。添加（新词）；
}
}else if（newWord.compareTo（value）>0）{
if（right==null）{
右=新BST（新词）；
}否则{
对。添加（新词）；
}
}
}
}
@凌驾
公共空白添加（Word）{
if（root==null）{
根=新的BST（字）；
}否则{
root.add（word）；
}
}
@凌驾
公共布尔包含（Word）{
返回false；
}
@凌驾
公共整数大小（）{
返回0；
}
私有类TreeWordSetIterator实现迭代器{
@凌驾
公共布尔hasNext（）{
返回false；
}
@凌驾
公共单词next（）{
返回null；
}
}
@凌驾
公共迭代器迭代器（）{
返回新的TreeWordSetIterator（）；
}
}

如果这是为了学习而做的练习，也许最好的方法就是去看看TreeSet是如何做到的。如果这是一个用于生产的练习，请立即停止，如果确实需要，请扩展TreeSet。

我用这种方式解决了它，它并不迷人。直到有人能提供更好的解决方案

    private class TreeWordSetIterator implements Iterator<Word> {
    Word arr[] = new Word[size()];
    int i = 0;
    TreeWordSetIterator(){
        traverse(root);
        i = 0;
    }

    private void traverse(BST currentNode) {
        if (currentNode == null) {
            return;
        }
        traverse(currentNode.left);
        arr[i] = currentNode.value;
        i++;
        traverse(currentNode.right);
    }

    @Override
    public boolean hasNext() {
        if (i < size()) {
            return true;
        } else {
            return false;
        }
    }

    @Override
    public Word next() {
        Word current = arr[i];
        i++;
        return current;

    }
}

私有类TreeWordSetIterator实现迭代器{
单词arr[]=新词[size（）]；
int i=0；
TreeWordSetIterator（）{
横移（根）；
i=0；
}
私有无效遍历（BST currentNode）{
if（currentNode==null）{
返回；
}
遍历（currentNode.left）；
arr[i]=currentNode.value；
i++；
遍历（currentNode.right）；
}
@凌驾
公共布尔hasNext（）{
如果（i

我不知道这是否是最正确的方法，但我认为最简单的方法是将树递归到集合中，然后返回集合的迭代器。这是一个练习。我一直在看全班是如何做到这一点的。但对于我正在尝试做的事情来说，它似乎要复杂得多，而且不连续。我不明白。我正在尝试制作一个更简单的迭代器。一个高效的迭代器（你的不是）需要在发现每个元素时捕获高效搜索的状态。状态或多或少由沿左子指针下降到当前节点时遇到的节点堆栈组成。