Using java to achieve the minimum spanning tree algorithm prim

Entity classes:

Package com.caicai.prim.entity;
 / ** 
 * 
 * @author caizy 
 * 
 * / 
public  class SHORTEDGE {
     Private  int LowCost; // to communicating the minimum weight tree 
    Private  int adjvex; // make it to a minimum the communication tree the node number of weights 
    public  int getLowCost () {
         return LowCost; 
    } 
    public  void setLowCost ( int LowCost) {
         the this .lowCost = LowCost; 
    } 
    public  int getAdjvex () {
         return adjvex;
    }
    public void setAdjvex(int adjvex) {
        this.adjvex = adjvex;
    }
    

}

Package com.caicai.prim.entity; 

public  class Graph <T> {
     Private  int vertexNum; // number of vertices 
    Private T Vertex []; // store vertex array information 
    Private  int arcNum; // store the number of sides; 
    Private  int ARC [] []; // store side relationship and edge weights: 0 when the edge is not present, there is greater than zero and side to side weights. 
    public  int getVertexNum () {
         return vertexNum; 
    } 
    public  void setVertexNum ( int vertexNum) {
         the this .vertexNum = vertexNum; 
    }
    public T[] getVertex() {
        return vertex;
    }
    public void setVertex(T[] vertex) {
        this.vertex = vertex;
    }
    public int getArcNum() {
        return arcNum;
    }
    public void setArcNum(int arcNum) {
        this.arcNum = arcNum;
    }
    public int[][] getArc() {
        return arc;
    }
    public void setArc(int[][] arc) {
        this.arc = arc;
    }
    
    

}

prim algorithm:

package com.caicai.prim;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

import com.caicai.prim.entity.Graph;
import com.caicai.prim.entity.ShortEdge;

/**
 * 
 * @author caizy
 *prim算法实现
 */
public class Prim<T> {
    private Map<Integer,ShortEdge> map = new HashMap<Integer, ShortEdge>();
    private Graph<T> graph;
    public Graph<T> getGraph() {
        return graph;
    }
    public void setGraph(Graph<T> graph) {
        this.graph = graph;
    }
    public Map<Integer,ShortEdge> prim() {
        initial();
        int arc[][]=graph.getArc();
        Map<Integer,ShortEdge> resultMap=new LinkedHashMap<Integer,ShortEdge>();
        while(map.size()>0) {
            int k = minEdge(map);
            resultMap.put(k,map.get(k) );
            map.remove(k);
            if(map.size()==0)
                break;
            for (int key:map.keySet()) {    
                if (arc[key][k] < map.get(key).getLowCost())
                    map.get(key).setLowCost(arc[k][key]);
                    map.get(key).setAdjvex(k);
            }    
        }
        return resultMap;
    }
    private void initial() {
        int arc[][]=graph.getArc();
        for(int i = 1; i < graph.getVertexNum(); i++) {
            ShortEdge shortEdge = new ShortEdge();
            shortEdge.setAdjvex(0);//开始的时候集合中只有一个顶点0
            if(arc[0][i]!=0)
                shortEdge.setLowCost(arc[0][i]);
            else
                shortEdge.setLowCost(Integer.MAX_VALUE);
            map.put(i,shortEdge);
        }
    }
    private int minEdge(Map<Integer,ShortEdge> map) {
        int min=Integer.MAX_VALUE;
        int found =0;
        for(Integer key: map.keySet()) {
            if(map.get(key).getLowCost()<min) {
                min=map.get(key).getLowCost();
                found=key;
            }
        }
        return found;
    }

}

测试类

package prim.test;

import java.util.Map;

import com.caicai.prim.Prim;
import com.caicai.prim.entity.Graph;
import com.caicai.prim.entity.ShortEdge;

public class PrimTest {
    
    public static void main(String args[]) {
        Graph<String> graph = new Graph<String>();
        graph.setVertexNum(4);
        graph.setArcNum(5);
        int arc[][] = new int[5][5];
        arc[0][1]=19;
        arc[1][0]=19;
        arc[1][2]=25;
        arc[2][1]=25;
        arc[1][3]=25;
        arc[3][1]=25;
        arc[2][3]=17;
        arc[3][2]=17;
        arc[2][0]=46;
        arc[0][2]=46;
        graph.setArc(arc);
        String vertex[]=new String[4];
        for (int i= 0;i<4;i++) {
            vertex[i]="顶点"+i;
        }
        graph.setVertex(vertex);
        Prim<String> prim =new Prim<String>();
        prim.setGraph(graph);
        Map<Integer,ShortEdge> resultMap=prim.prim();
        for(int key:resultMap.keySet()) {
            System.out.format("边为%d"+"-"+"%d,"+"权值为：%d\n",key,resultMap.get(key).getAdjvex(),
                    resultMap.get(key).getLowCost());
        }
        
    }

}

 测试结果：

参考书籍：数据结构（c++版）第2版 王红梅等编著