菜鸟笔记之数据结构（22）

声明：以下是学的尚硅谷网课并结合网上资料所记的笔记。可能会有一些错误，发现了会修改。

普利姆（Prim）算法

应用场景-修路问题

思路： 修路问题的本质就是最小生成树的问题，最小生成树（Minimum Cost Spanning Tree），简称MST。

1. 给定一个带权的无向连通图，如何选取一颗生成树，使树上的所有边上权的总和为最小，这叫最小生成树。
2. N个顶点，一定有N-1条边。
3. 包含全部顶点。
4. N-1条边都在图中。
5. 求最小生成树的算法主要是普利姆算法和克鲁斯卡尔算法。

普利姆算法介绍

1. 普利姆（Prim）算法求最小生成树，就是在包含n个顶点的连通图中，找出只有（n-1）条边包含所有 n 个顶点的连通子图，也就是所谓的极小连通子图。

2. 普利姆算法步骤：
   （1）设G =（V, E）是连通网，T =（U, D）是最小生成树，V, U是顶点结合，E, D是边的集合；
   （2）若从顶点 u 开始构造最小生成树，则从集合 V 中取出顶点 u 放入集合U中，标记顶点 v 的visited[ u ] = 1；
   （3）若集合U中顶点 u_i 与集合V - U中的顶点 v_j 之间存在边，则寻找这些边中权值最小的边，但不能构成回路，将顶点 v_j 加入集合U中，将边（u_i, v_j）加入集合D中，标记visited[ v_j ] = 1；
   （4）重复步骤（2），直到U与V相等，即所有顶点都被标记为访问过，此时D中有n-1条边；
   （5）提示：单独看步骤很难理解，看代码帮助理解。

图解分析

可以看出，7个顶点的极小连通子图有6条边。

代码

import java.util.Arrays;

public class PrimAlgorithm {

	public static void main(String[] args) {
		//测试看看图是否创建成功
		char[] data = new char[] {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
		int verxs = data.length;
		//邻接矩阵的关系使用二维数组描述，用10000表示各地之间不连通
		int[][] weight = new int[][] {
			{10000,5,7,10000,10000,10000,2},  
			{5,10000,10000,9,10000,10000,3},
			{7,10000,10000,10000,8,10000,10000},
			{10000,9,10000,10000,10000,4,10000},
			{10000,10000,8,10000,10000,5,4},
			{10000,10000,10000,4,5,10000,6},
			{2,3,10000,10000,4,6,10000}};
			
		//创建MGraph对象
		MGraph graph = new MGraph(verxs);
		//创建一个MinTree对象
		MinTree minTree = new MinTree();
		minTree.createGraph(graph, verxs, data, weight);
		//输出
		//minTree.showGraph(graph);
		//测试普利姆算法
		minTree.prim(graph, 0);
	}
}

//创建最小生成树
class MinTree{
	//创建图的邻接矩阵
	/**
	 * 
	 * @param graph     图对象
	 * @param verxs 	图对应的顶点个数
	 * @param data  	图的各个顶点的值
	 * @param weight	图的邻接矩阵
	 */
	public void createGraph(MGraph graph, int verxs, char data[], int[][] weight){
		int i, j;
		for(i  = 0; i < verxs; i++) { //顶点
			graph.data[i] = data[i];
			for(j = 0; j < verxs; j++) {
				graph.weight[i][j] = weight[i][j];
			}
		}
	}
	
	//显示图的方法
	public void showGraph(MGraph graph) {
		for(int[] link : graph.weight) {
			System.out.println(Arrays.toString(link));
		}
	}
	
	//编写Prim算法得到最小生成树
	/**
	 * @param graph	图
	 * @param verxs	表示从图的第几个顶点开始生成。'A'->0, 'B'->1.。
	 */
	public void prim(MGraph graph, int verxs) {
		//visited 用来标记结点是否被访问过，默认元素都是0，表示没有访问过
		int[] visited = new int[graph.verxs];
		//把当前这个结点标记为已访问
		visited[verxs] = 1;
		//h1和h2记录两个顶点的下标
		int h1 = -1;
		int h2 = -1;
		int minWeight = 10000; //将minWeight初始化为一个大值，后面在遍历过程中会被替换
		//因为有graph.verxs个顶点，普利姆算法结束后，会有graph.verxs-1条边
		for(int k = 1; k < graph.verxs; k++) {
			//确定每一次生成的子图，和哪个结点的距离最近
			for(int i = 0; i < graph.verxs; i++) { //i结点表示被访问过的节点
				for(int j = 0; j < graph.verxs; j++) {	//j节点表示还没有访问过的节点
					if(visited[i] == 1 && visited[j] == 0 && graph.weight[i][j] < minWeight) {
						//替换minWeight（寻找已经访问过的结点和未访问过的结点的权值最小的边）
						minWeight = graph.weight[i][j];
						h1 = i;
						h2 = j;
					} 
				}
			}
			//找到了一条边是最小的
			System.out.println("边<" + graph.data[h1] + "," + graph.data[h2] + "> 权值：" +  minWeight);
			//将当前这个结点标记为已经访问
			visited[h2] = 1;
			//将minWeight重置为最大值
			minWeight = 10000;
		}
	}
}

class MGraph{
	int verxs; //表示图的节点个数
	char[] data; //存放结点数据
	int[][] weight; //存放边，就是我们的邻接矩阵
	
	public MGraph(int verxs) {
		this.verxs = verxs;
		data = new char[verxs];
		weight = new int[verxs][verxs];
	}
} 

输出：
边<A,G> 权值：2
边<G,B> 权值：3
边<G,E> 权值：4
边<E,F> 权值：5
边<F,D> 权值：4
边<A,C> 权值：7
最小权值即最短路径为25。

--------------------------------------- 个人学习笔记----------------------------------------