自定义treeSet类，如何编写迭代器

import java.util.Iterator;
import java.util.NoSuchElementException;

public class CustomTreeSet<T> implements Iterable<T> {
    private Node<T> root;
    private int size;

    private static class Node<T> {
        private T value;
        private Node<T> left;
        private Node<T> right;

        public Node(T value) {
            this.value = value;
            this.left = null;
            this.right = null;
        }
    }

    public CustomTreeSet() {
        this.root = null;
        this.size = 0;
    }

    public void add(T value) {
        if (contains(value)) {
            return;
        }
        root = addRecursive(root, value);
        size++;
    }

    private Node<T> addRecursive(Node<T> current, T value) {
        if (current == null) {
            return new Node<>(value);
        }

        if (value.compareTo(current.value) < 0) {
            current.left = addRecursive(current.left, value);
        } else {
            current.right = addRecursive(current.right, value);
        }

        return current;
    }

    public boolean contains(T value) {
        return containsRecursive(root, value);
    }

    private boolean containsRecursive(Node<T> current, T value) {
        if (current == null) {
            return false;
        }

        if (value.compareTo(current.value) == 0) {
            return true;
        }

        if (value.compareTo(current.value) < 0) {
            return containsRecursive(current.left, value);
        } else {
            return containsRecursive(current.right, value);
        }
    }

    public int size() {
        return size;
    }

    @Override
    public Iterator<T> iterator() {
        return new TreeSetIterator();
    }

    private class TreeSetIterator implements Iterator<T> {
        private Node<T> nextNode;

        public TreeSetIterator() {
            nextNode = findMinimum(root);
        }

        private Node<T> findMinimum(Node<T> node) {
            if (node == null) {
                return null;
            }

            while (node.left != null) {
                node = node.left;
            }

            return node;
        }

        @Override
        public boolean hasNext() {
            return nextNode != null;
        }

        @Override
        public T next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }

            Node<T> current = nextNode;
            nextNode = findSuccessor(nextNode);
            return current.value;
        }

        private Node<T> findSuccessor(Node<T> node) {
            if (node.right != null) {
                return findMinimum(node.right);
            }

            Node<T> successor = null;
            Node<T> ancestor = root;

            while (ancestor != node) {
                if (node.value.compareTo(ancestor.value) < 0) {
                    successor = ancestor;
                    ancestor = ancestor.left;
                } else {
                    ancestor = ancestor.right;
                }
            }

            return successor;
        }
    }
}