Как реализовать алгоритм Крускала в Java с нецелыми вершинами?

Question

Я пытался реализовать алгоритм Крускала на моем графике, который не ориентирован и взвешен. Тем не менее, во всех реализациях, которые я видел, вершины определены как целые числа, но в моем проекте я определил их как класс Vertex. Я хотел бы знать, как реализовать алгоритм Крускала с нецелыми вершинами.

Я попытался адаптировать реализации к тому, что мне нужно, но я не могу этого сделать, поскольку реализации используют find (int v), rank [] и parent [].

public class UndirectedGraph<A, V> {

    private int numEdges;

    private int numVertices;

    private Edge[] edgeList;

    private SeparateChainingHashST<String , Vertice> hash;

    public UndirectedGraph() {

        numEdges = 0;
        numVertices = 0;
        hash = new SeparateChainingHashST<>();
    }


    public Vertice getVertice(String key) {
        return hash.get(key);
    }

    public Iterable<String> getVertices() {
        return hash.keys();
    }

    public List<Vertice> getVerticesList() {
        Iterator<String> it = hash.keys().iterator();
        ArrayList<Vertice> array = new ArrayList<>();

        while (it.hasNext())
        {
            String key = it.next();
            array.add(hash.get(key));
        }

        return array;
    }

    /**
     * Da el numero de vertices que tiene el grafo
     * @return numero de vertices
     */
    public int V() {
        return numVertices;
    }

    /**
     * Da el numero de arcos que tiene el grafo
     * @return numero de arcos 
     */
    public int E() {
        return numEdges;
    }

    public Edge[] getEdges() {
        return edgeList;
    }

    public List<Edge> getEdgesList()
    {
        ArrayList<Edge> al = new ArrayList<>();

        int i = 0;
        while (i < edgeList.length)
        {
            al.add(edgeList[i]);
            i++;
        }

        return al;
    }

    /**
     * Agrega un vertice nuevo el arco
     * @param key
     * @param vertice
     */
    public void addVertice(String key, Vertice vertice ) {
        hash.put(key, vertice);
        numVertices++;
    }

    /**
     * Agrega un arco nuevo al grafo
     * @param id1
     * @param id2
     * @param info
     * @param cost
     */
    public void addEdge(String id1, String id2, A info, float cost ) {
        Vertice<V> vertice1 = hash.get(id1);
        Vertice<V> vertice2 = hash.get(id2);

        Edge edge = new Edge(cost, info, vertice1, vertice2);
        edgeList[numEdges] = edge;
        numEdges++;
    }

    /**
     * Da la informacion del vertice dado
     * @param id
     * @return V
     */
    public V getInfoVertex(String id ) {
        Vertice<V> vertex = hash.get(id);
        return vertex.getInfo();
    }

    /**
     * Se cambia l ainformcion del vertice dado por la dada por parametro
     * @param idVertex
     * @param infoVertex
     */
    public void setInfoVertex(String idVertex, V infoVertex){
        Vertice<V> vertex = hash.get(idVertex);
        vertex.setInfo(infoVertex);
    }

    /**
     * Da la informacion del arco que se encuentra entre los dos arcos dados
     * @param id1
     * @param id2
     * @return Informacion del arco
     */
    public A getInfoEdge(String id1, String id2 ) {
        A info = null;
        for (Edge edge : edgeList) {
            String idVertex1 = edge.getVertice1().getKey();
            String idVertex2 = edge.getVertice2().getKey();
            if( (idVertex1.equals(id1) && idVertex2.equals(id2)) || (idVertex1.equals(id2) && idVertex2.equals(id1)) ) {
                info =  (A) edge.getInfo();
                return info;

            }
        }
        return info;
    }

    /**
     * Cambia la informacion del arco que se encuentra entre los dos vertices dados 
     * @param id1
     * @param id2
     * @param info
     */
    public void setInfoEdge(String id1, String id2, A info ) {
        for (Edge edge : edgeList) {
            String idVertex1 = edge.getVertice1().getKey();
            String idVertex2 = edge.getVertice2().getKey();
            if( (idVertex1.equals(id1) && idVertex2.equals(id2)) || (idVertex1.equals(id2) && idVertex2.equals(id1)) ) {
                edge.setInfo(info);
                return;
            }
        }
    }

    /**
     * Retorna los identificadores de los vertices adyacentes al vertice dado por parametro
     * @param idVertex
     * @return Identificadores de los vertices adyacentes
     */
    public Iterable<String> adj(String idVertex){
        IQueue<String> queue = new Queue<>();
        ArrayList<Vertice<V>> vertex =  hash.get(idVertex).getAdj();
        for (Vertice<V> vertice : vertex) {
            queue.enqueue(vertice.getKey());
        }
        return queue;
    }


}