Java实现图的普里姆算法

import java.util.LinkedList;

/**
 * 图的数据结构
 * @author lyc
 *
 */
public class Graph implements GraphIt{
	
	// v图的定点数
	private String[] vertices;
	
	// matrix邻接矩阵
	private int[][] matrix;
	
	// 边的数目
	private int numOfEdges;
	
	// 点的访问标记
	private boolean[] flag;
	
	
	/**
	 * 通过指定顶点数,构造图
	 * @param n
	 */
	public Graph(int n) {
		vertices = new String[n];
		matrix = new int[n][n];
		flag = new boolean[n];
		numOfEdges = 0;
		// flag初始化访问节点的状态
		for (int i = 0; i < flag.length; i++) {
			flag[i] = false;
		}
		
		// matrix初始化图
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				if(i == j) {
					matrix[i][j] = 0;
				}else {
					matrix[i][j] = Integer.MAX_VALUE;
				}
			}
		}
	}
	
	/**
	 * 初始化顶点
	 * @param vertices
	 */
	public void initVertices(String[] vertices) {
		this.vertices = vertices;
	}
	
	
	/**
	 * 指定顶点确定一条边
	 * @param v1 
	 * @param v2
	 */
	public void insertEdge(int v1,int v2,int weight) {
		matrix[v1][v2] = weight;
		numOfEdges++;
	}
	

	/**
	 * 最小生成树普里姆算法
	 * @param n 顶点数
	 */
	public void Prim(int n) {
		// 存储最短路径的边,mst[1] = 0,代表从0到1的边
		int[] mst = new int[n];
		
		// weight存储边的权值
		int[] lowCost = new int[n];
		
		for (int i = 1; i < vertices.length; i++) {
			// v0指向各条边的权值
			lowCost[i] = matrix[0][i];
			// v0是起点
			mst[i] = 0;
		}
		
		for (int i = 1; i < vertices.length; i++) {
			
			int min = Integer.MAX_VALUE;
			int k = 0;
			
			// 从lowCost[j]这些边里面找一个最小的边,取到j这个终点
			for (int j = 1; j < n; j++) {
				if(lowCost[j] != 0 && lowCost[j] < min) {
					min = lowCost[j];
					// vertice下一个比较的起点
					k = j;
				}
			}
			
			// lowCost[k] = 0 表示指向k的终点被访问过
			lowCost[k] = 0;
			
			// 起点mst[k]的值  ---> 终点k
			System.out.println("边: "+mst[k]+"->"+k);
			
			for (int j = 1; j < vertices.length; j++) {
				if(lowCost[j] != 0 && matrix[k][j] < lowCost[j]) {
					// edge以j为终点的边,k是起点 
					lowCost[j] = matrix[k][j];
					mst[j] = k;
				}
			}
		}
	}
	
}

/**
 * 图的测试类
 * @author lyc
 *
 */
public class Test {
	public static void main(String[] args) {
		Graph g = new Graph(9);
		String[] vertices = {"v0","v1","v2","v3","v4","v5","v6","v7","v8"};
		g.initVertices(vertices);
		// v0
		g.insertEdge(0,1,10);
		g.insertEdge(0,5,11);
		// v1
		g.insertEdge(1,0,10);
		g.insertEdge(1,2,18);
		g.insertEdge(1,8,12);
		g.insertEdge(1,6,16);
		// v2
		g.insertEdge(2,1,18);
		g.insertEdge(2,8,8);
		g.insertEdge(2,3,22);
		// v3
		g.insertEdge(3,2,22);
		g.insertEdge(3,8,21);
		g.insertEdge(3,6,24);
		g.insertEdge(3,7,16);
		g.insertEdge(3,4,20);
		// v4
		g.insertEdge(4,3,20);
		g.insertEdge(4,7,7);
		g.insertEdge(4,5,26);
		// v5
		g.insertEdge(5,6,17);
		g.insertEdge(5,0,11);
		g.insertEdge(5,4,26);
		// v6
		g.insertEdge(6,1,16);
		g.insertEdge(6,5,17);
		g.insertEdge(6,3,24);
		g.insertEdge(6,7,19);
		// v7
		g.insertEdge(7,6,19);
		g.insertEdge(7,3,16);
		g.insertEdge(7,4,7);
		// v8
		g.insertEdge(8,1,12);
		g.insertEdge(8,2,8);
		g.insertEdge(8,3,21);
		g.Prim(9);
	}
}

图的邻接矩阵以及图片可以参考博客:https://blog.csdn.net/junya_zhang/article/details/83544709