介绍了图的最小生成树的概念，然后介绍了求最小生成树的两种算法：prim算法和kruskal算法的原理，最后提供了基于邻接矩阵和邻接链表的图对两种算法的java实现。
阅读本文需要一定的图的基础，如果对于图不是太明白的可以看看这篇文章：java数据结构之图的原理与实现。
生成树（spanningtree）：一个连通图的生成树是指一个连通子图，它含有图中全部n个顶点，但只有足以构成一棵树的n-1条边。一颗有n个顶点的生成树有且仅有n-1条边，如果生成树中再添加一条边，则必定成环。
最小生成树（minimum spanning tree）：在连通图的所有生成树中，所有边的权值和最小的生成树，称为最小生成树。
在生活中，图形结构的应用是最广泛的。比如常见的通信网络搭建路线选择，村庄可以看作顶点，村庄之间如果有通信路径，则算作两点之间的边或者弧，两个村庄之间的通信成本，可以看作边或者弧的权值。
上图就是生活中通信网络搭建路线的选择映射到图形结构的案例。顶点作为村庄，村庄之间如果有通信路径则拥有边，村庄的之间的通信搭建成本则是边的权值。
一种很常见的需求是要求对于能够通信的村庄都必须通信，并且通信建设成本和最小，毕竟经费“有限”，省下来的经费，嘿嘿！
上面的问题，转换为数学模型，就是求一个图的最小生成树的问题，即：选出一条路线，连通了所有能够连通顶点，并且权值和最小。这样的问题已经有了很多种解法，最经典的有两种算法，普里姆（prim）算法和克鲁斯卡尔（kruskal)算法。
普里姆（prim）算法是以某顶点为起点，假设所有顶点均未连接，逐步找各顶点上最小权值的边来连接并构建最小生成树。是以点为目标去构建最小生成树。
具体的步骤是： 首先随机选取一个顶点a，寻找顶点a可连接所有的顶点，选择一个权值低的顶点进行连接；然后寻找与这两个顶点或可连接的所有顶点，选择一个权值低的顶点与其中一个顶点进行连接；如此往复n-1次，每次选择距离任穿越火线游戏名字意一个已连接末端顶点最短的顶点（而不是距离首个顶点最短的顶点）进行连接，直到所有的顶点都进行连接，至此最小生成树构建完毕。
该案例对应着下面实现代码中的案例。
在上面的图中，首先选择顶点a作为已连接点，寻找顶点a可连接所有的顶点c、d、f，选择一个权值低的顶点进行连接，这里选择a-c；
然后寻找与a或c可连接的所有顶点（排除已连接的点），找到b、d、f，一共有4条边可选，a-d、a-f、c-b、c-d，选择一个权值低的顶点与其中一个顶点进行连接，这里明显选择a-d连接；
然后寻找与a或c或d可连接的所有顶点（排除已连接的点），找到b、f，一共有3条边可选，c-b、d-b、a-f，选择一个权值低的顶点与其中一个顶点进行连接，这里明显选择a-f连接；
然后寻找与a或c或d或f可连接的所有顶点（排除已连接的点），找到b、g，一共有3条边可选，c-b、d-b、f-g，选择一个权值低的顶点与其中一个顶点进行连接，这里明显选择c-b连接；
然后寻找与a或c或d或f或b可连接的所有顶点（排除已连接的点），找到e、g，一共有2条边可选，b-e、f-g，选择一个权值低的顶点与其中一个顶点进行连接，这里明显选择b-e连接；
然后寻找与a或任命书格式c或d或f或b或e可连接的所有顶点（排除已连接的点），找到g，一共有2条边可选，e-g、f-g，选择一个权值低的顶点与其中一个顶点进行连接，这里明显选择e-g连接；
所有的顶点连接完毕，此时最小生成树已经构建好了，最小权值为23。
克鲁斯卡尔算法（kruskal）根据边的权值以递增的方式逐渐建立最小生成树，是以边为目标去构建最小生成树。
具体的步骤是： 将加权图每个顶点都看做森林，然后将图中每条邻接边的权值按照升序的方式进行排列，接着从排列好的邻接边表中抽取权值最小的边，写入该边的起始顶点和结束顶点，连接顶点将森林构成树，然后读取起始结束顶点的邻接边，优先抽取权值小的邻接边，继续连接顶点将森林构成树。添加邻接边的要求是加入到图中的邻接边不构成回路（环）。如此反复进行，直到已经添加n-1条边为止。至此最小生成树构建完毕。
该案例对应着下面实现代码中的案例，传统kruskal算法过程如下：
首先获取边集数组并按照权值重小到大进行排序，在代码中的排序本人直接使用的sort排序，也可以自己实现堆排序，排序后结果如下：
edge{from=a, to=c, weight=1}
edge{from=d, to=a, weight=2}
edge{from=a, to=f, weight=3}
edge{from=b, to=c, weight=4}
edge{from=c, to=d, weight=5}
edge{from=e, to=g, weight=6}
edge{from=e, 春节法定假期to=b, weight=7}
edge{from=d, to=b, weight=8}
edge{from=f, to=g, weight=9}
循环取出第1条边a-c，判断与已经找到的最小生成树不会形成环，权值总和增加1，继续；
循环取出第2条边d-a，判断与已经找到的最小生成树不会形成环，权值总和增加2，继续；
循环取出第3条边a-f，判断与已经找到的最小生成树不会形成环，权值总和增加3，继续；
循环取出第4条边b-c，判断与已经找到的最小生成树不会形成环，权值总和增加4，继续；
循环取出第5条边c-d，判断与已经找到的最小生成树会形成环，该条边丢弃，继续；
循环取出第6条边e-g，判断与已经找到的最小生成树不会形成环，权值总和增加6，继续；
循环取出第7条边e-b，判断与已经找到的最小生成树不会形成环，权值总和增加7，继续；
循环取出第8条边d-b，判断与已经找到的最小生成树会形成环，该条边丢弃，继续；
循环取出第9条边f-g，判断与已经找到的最小生成树会形成环，该条边丢弃，继续；
此时循环结束，那么最小生成树也已经找到了，最小生成树的权值总和为23。
上面步骤中，判断是否形成环很关键，通常的做法是，对已经找到的最小生成树的顶点进行排序（从起点到终点)，然后每新添加一条边，就使用新添加边的起点和终点取最小二叉树中寻找，排序后的终点，找到的终点一致，则说明最小生成树加上这条边就会形成环，否则说明不会，那么更新排序的终点。
这里的实现能够构造一个基于邻接矩阵实现无向加权图的类，并且提供深度优先遍历和广度优先遍历的方法，提供获取边集数组的方法，提供prim和kruskal两种求最小生成树的方法。
/*** 无向加权图邻接矩阵实现* {@link matrixprimandkruskal#matrixprimandkruskal(e[], edge[])} 构建无向加权图* {@link matrixprimandkruskal#dfs()} 深度优先遍历无向加权图* {@link matrixprimandkruskal#bfs()} 广度优先遍历无向加权图* {@link matrixprimandkruskal#tostring()} 输出无向加权图* {@link matrixprimandkruskal#prim()} prim算法实现最小生成树* {@link matrixprimandkruskal#kruskal()} kruskal算法实现最小生成树* {@link matrixprimandkruskal#kruskalandprim()} kruskal算法结合prim算法实现最小生成树* {@link matrixprimandkruskal#getedges()} 获取边集数组** @author lx* @date 2020/5/14 18:13*/public class matrixprimandkruskal<e> {/*** 顶点数组*/private object[] vertexs;/*** 邻接矩阵*/private int[][] matrix;/****/private edge<e>[] edges;/*** 由于是加权图,这里设置一个边的权值上限,任何边的最大权值不能大于等于该值，在实际应用中，该值应该根据实际情况确定*/private static final int no_edge = 99;/*** 边对象,具有权值,在构建加权无向图时使用*/private static class edge<e> {private e from;private e to;private int weight;public edge(e from, e to, int weight) {this.from = from;this.to = to;this.weight = weight;}@overridepublic string tostring() {return "edge{" +"from=" + from +", to=" + to +", weight=" + weight +'}';}}/*** 创建无向加权图** @param vertexs 顶点数组* @param edges 边对象数组*/public matrixprimandkruskal(object[] vertexs, edge<e>[] edges) {//初始化边数组this.edges = edges;// 初始化顶点数组,并添加顶点this.vertexs = arrays.copyof(vertexs, vertexs.length);// 初始化边矩阵,并预先填充边信息this.matrix = new int[vertexs.length][vertexs.length];for (int i = 0; i < vertexs.length; i++) {for (int j = 0; j < vertexs.length; j++) {if (i == j) {this.matrix[i][j] = 0;} el {this.matrix[i][j] = no_edge;}}}for (edge<e> edge : edges) {// 读取一条边的起始顶点和结束顶点索引值int p1 = getposition(edge.from);int p2 = getposition(edge.to);//对称的两个点位都置为edge.weight,无向图可以看作相互可达的有向图this.matrix[p1][p2] = edge.weight;this.matrix[p2][p1] = edge.weight;}}/*** 获取某条边的某个顶点所在顶点数组的索引位置** @param e 顶点的值* @return 所在顶点数组的索引位置, 或者-1 - 表示不存在*/private int getposition(e e) {for (int i = 0; i < vertexs.length; i++) {if (vertexs[i] == e) {return i;}}return -1;}/*** 深度优先搜索遍历图,类似于树的前序遍历,*/public void dfs() {//新建顶点访问标记数组,对应每个索引对应相同索引的顶点数组中的顶点boolean[] visited = new boolean[vertexs.length];//初始化所有顶点都没有被访问for (int i = 0; i < vertexs.length; i++) {visited[i] = fal;}system.out.println("dfs: ");for (int i = 0; i < vertexs.length; i++) {if (!visited[i]) {dfs(i, visited);}}system.out.println();}/*** 深度优先搜索遍历图的递归实现,类似于树的先序遍历* 因此模仿树的先序遍历,同样借用栈结构,这里使用的是方法的递归,隐式的借用栈** @param i 顶点索引* @param visited 访问标志数组*/private void dfs(int i, boolean[] visited) {visited[i] = true;system.out.print(vertexs[i] + " ");// 遍历该顶点的所有邻接点。若该邻接点是没有访问过，那么继续递归遍历领接点for (int w = firstvertex(i); w >= 0; w = nextvertex(i, w)) {if (!visited[w]) {dfs(w, visited);}}}/*** 广度优先搜索图,类似于树的层序遍历* 因此模仿树的层序遍历,同样借用队列结构*/public void bfs() {// 辅组队列queue<integer> indexlinkedlist = new linkedlist<>();//新建顶点访问标记数组,对应每个索引对应相同索引的顶点数组中的顶点boolean[] visited = new boolean[vertexs.length];for (int i = 0; i < vertexs.length; i++) {visited[i] = fal;}system.out.println("bfs: ");for (int i = 0; i < vertexs.length; i++) {if (!visited[i]) {visited[i] = true;system.out.print(vertexs[i] + " ");indexlinkedlist.add(i);}if (!indexlinkedlist.impty()) {//j索引出队列integer j = indexlinkedlist.poll();//继续访问j的邻接点for (int k = firstvertex(j); k >= 0; k = nextvertex(j, k)) {if (!visited[k]) {visited[k] = true;system.out.print(vertexs[k] + " ");//继续入队列indexlinkedlist.add(k);}}}}system.out.println();}/*** 返回顶点v的第一个邻接顶点的索引，失败则返回-1** @param v 顶点v在数组中的索引* @return 返回顶点v的第一个邻接顶点的索引，失败则返回-1*/private int firstvertex(int v) {//如果索引超出范围,则返回-1if (v < 0 || v > (vertexs.length - 1)) {return -1;}/*根据邻接矩阵的规律:顶点索引v对应着边二维矩阵的matrix[v][i]一行记录* 从i=0开始*/for (int i = 0; i < vertexs.length; i++) {if (matrix[v][i] != 0 && matrix[v][i] != no_edge) {return i;}}return -1;}/*** 返回顶点v相对于w的下一个邻接顶点的索引，失败则返回-1** @param v 顶点索引* @param w 第一个邻接点索引* @return 返回顶点v相对于w的下一个邻接顶点的索引，失败则返回-1*/private int nextvertex(int v, int w) {//如果索引超出范围,则返回-1if (v < 0 || v > (vertexs.length - 1) || w < 0 || w > (vertexs.length - 1)) {return -1;}/*根据邻接矩阵的规律:顶点索引v对应着边二维矩阵的matrix[v][i]一行记录* 由于邻接点w的索引已经获取了,所以从i=w+1开始寻找*/for (int i = w + 1; i < vertexs.length; i++) {if (matrix[v][i] != 0 && matrix[v][i] != no_edge) {return i;}}return -1;}/*** 输出图** @return 输出图字符串*/@overridepublic string tostring() {stringbuilder stringbuilder = new stringbuilder();for (int i = 0; i < vertexs.length; i++) {for (int j = 0; j < vertexs.length; j++) {stringbuilder.append(matrix[i][j]).append("\t");}stringbuilder.append("\n");}return stringbuilder.tostring();}/*** prim算法求最小生成树*/public void prim() {system.out.println("prim: ");//对应节点应该被连接的前驱节点,用来输出//默认为0,即前驱结点为第一个节点int[] mid = new int[matrix.length];//如果某顶点作为末端顶点被连接，对应位置应该为true//第一个顶点默认被连接boolean[] connected = new boolean[matrix.length];connected[0] = true;//存储未连接顶点到已连接顶点的最短距离(最小权)int[] dis = new int[matrix.length];//首先将矩阵第一行即其他顶点到0索引顶点的权值拷贝进去system.arraycopy(matrix[0], 0, dis, 0, matrix.length);//存储路径长度int sum = 0;//最小权值int min;/*默认第一个顶点已经找到了,因此最多还要需要大循环n-1次*/for (int k = 1; k < matrix.length; k++) {min = no_edge;//最小权值的顶点的索引int minindex = 0;/*寻找权值最小的且未被连接的顶点索引*/for (int i = 1; i < matrix.length; i++) {//排除已连接的顶点,排除权值等于0的值,这里权值等于0表示已生成的最小生成树的顶点都未能与该顶点连接if (!connected[i] && dis[i] != 0 && dis[i] < min) {min = dis[i];minindex = i;}}//如果没找到,那么该图可能不是连通图,直接返回了,此时最小生成树没啥意义if (minindex == 0) {return;}//权值和增加sum += min;//该新连接顶点对应的索引值变成true,表示已被连接,后续判断时跳过该顶点connected[minindex] = true;//输出对应的前驱顶点到该最小顶点的权值system.out.println(vertexs[mid[minindex]] + " ---> " + vertexs[minindex] + " 权值:" + min);/*在新顶点minindex加入之前的其他所有顶点到连接顶点最小的权值已经计算过了因此只需要更新其他未连接顶点到新连接顶点minindex是否还有更短的权值,有的话就更新找到距离已连接的顶点权最小的顶点*/for (int i = 1; i < matrix.length; i++) {//如果该顶点未连接if (!connected[i]) {/*如果新顶点到未连接顶点i的权值不为0,并且比原始顶点到未连接顶点i的权值还要小,那么更新对应位置的最小权值*/if (matrix[minindex][i] != 0 && dis[i] > matrix[minindex][i]) {//更新最小权值dis[i] = matrix[minindex][i];//更新前驱节点索引为新加入节点索引mid[i] = minindex;}}}}system.out.println("sum: " + sum);}/*** kruskal算法求最小生成树传统实现,要求知道边集数组,和顶点数组*/public void kruskal() {system.out.println("kruskal: ");//由于创建图的时候保存了边集数组,这里直接使用就行了//edge[] edges = getedges();//this.edges=edges;//对边集数组进行排序arrays.sort(this.edges, comparator.comparingint(o -> o.weight));// 用于保存已有最小生成树中每个顶点在该最小树中的最终终点的索引int[] vends = new int[this.edges.length];//能够知道终点索引范围是[0,this.edges.length-1],因此填充edges.length表示没有终点arrays.fill(vends, this.edges.length);int sum = 0;for (edge<e> edge : this.edges) {// 获取第i条边的起点索引fromint from = getposition(edge.from);// 获取第i条边的终点索引toint to = getposition(edge.to);// 获取顶点from在"已有的最小生成树"中的终点int m = getendindex(vends, from);// 获取顶点to在"已有的最小生成树"中的终点int n = getendindex(vends, to);// 如果m!=n，意味着没有形成环路,则可以添加,否则直接跳过,进行下一条边的判断if (m != n) {//添加设置原始终点索引m在已有的最小生成树中的终点为nvends[m] = n;system.out.println(vertexs[from] + " ---> " + vertexs[to] + " 权值:" + edge.weight);sum += edge.weight;}}system.out.println("sum: " + sum);//system.out.println(arrays.tostring(this.edges));}/*** 获取顶点索引i的终点如果没有终点则返回顶点索引本身** @param vends 顶点在最小生成树中的终点* @param i 顶点索引* @return 顶点索引i的终点如果没有终点则返回顶点索引本身*/private int getendindex(int[] vends, int i) {//这里使用循环查找的逻辑,寻找的是最终的终点while (vends[i] != this.edges.length) {i = vends[i];}return i;}/*** 如果没有现成的边集数组，那么根据邻接矩阵结构获取图中的边集数组** @return 图的边集数组*/private edge[] getedges() {list<edge> edges = new arraylist<>();/*遍历矩阵数组 只需要遍历一半就行了*/for (int i = 0; i < vertexs.length; i++) {for (int j = i + 1; j < vertexs.length; j++) {//如果存在边if (matrix[i][j] != no_edge && matrix[i][j] != 0) {edges.add(new edge<>(vertexs[i], vertexs[j], matrix[i][j]));//edges[index++] = new edge(vertexs[i], vertexs[j], matrix[i][j]);}}}return edges.toarray(new edge[0]);}/*** kruskal结合prim算法.不需要知道边集,只需要矩阵数组,和顶点数组* 同样是求最小权值的边,但是有一个默认起点顶点,该起点可以是要求[0,顶点数量-1]之间的任意值，同时查找最小权的边。* 可能会有bug,目前未发现*/public void kruskalandprim() {system.out.println("kruskalandprim: ");//已经找到的边携带的顶点对应的索引将变为true,其余未找到边对应的顶点将是falboolean[] connected = new boolean[matrix.length];//这里选择第一个顶点为起点,表示以该顶点开始寻找包含该顶点的最小边connected[0] = true;int sum = 0, n1 = 0, n2 = 0;//最小权值int min;while (true) {min = no_edge;/*找出所有带有已找到顶点的边中,最小权值的边,只需要寻找对称矩阵的一半即可*///第一维for (int i = 0; i < matrix.length; i++) {//第二维for (int j = i + 1; j < matrix.length; j++) {//排除等于0的,排除两个顶点都找到了的,这里实际上已经隐含了排除环的逻辑,如果某条边的两个顶点都找到了,那么如果算上该条边,肯定会形成环//寻找剩下的最小的权值的边if (matrix[i][j] != 0 && connected[i] != connected[j] && matrix[i][j] < min) {min = matrix[i][j];n1 = i;n2 = j;}}}//如果没找到最小权值,该图可能不是连通图,或者已经寻找完毕,直接返回if (min == no_edge) {system.out.println(" sum:" + sum);return;}//已经找到的边对应的两个顶点都置为trueconnected[n1] = true;connected[n2] = true;//输出找到的边和最小权值system.out.println(vertexs[n1] + " ---> " + vertexs[n2] + " 权值:" + min);sum += min;}}public static void main(string[] args) {//顶点数组character[] vexs = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};//边数组,加权值edge[] edges = {new edge<>('a', 'c', 1),new edge<>('d', 'a', 2),new edge<>('a', 'f', 3),new edge<>('b', 'c', 4),new edge<>('c', 'd', 5),new edge<>('e', 'g', 6),new edge<>('e', 'b', 7),new edge<>('d', 'b', 8),new edge<>('f', 'g', 9)};//构建图matrixprimandkruskal<character> matrixprimandkruskal = new matrixprimandkruskal<character>(vexs, edges);//输出图system.out.println(matrixprimandkruskal);//深度优先遍历matrixprimandkruskal.dfs();//广度优先遍历matrixprimandkruskal.bfs();//prim算法输出最小生成树matrixprimandkruskal.prim();//kruskal算法输出最小生成树matrixprimandkruskal.kruskal();//kruskal算法结合prim算法输出最小生成树,可能会有bug,目前未发现matrixprimandkruskal.kruskalandprim();//获取边集数组edge[] edges1 = matrixprimandkruskal.getedges();system.out.println(arrays.tostring(edges1));}}这里的实现能够构造一个基于邻接表实现无向加权图的类；并且提供深度优先遍历和广度优先遍历的方法，提供获取边集数组的方法，提供prim和kruskal两种求最小生成树的方法。
/*** 无向加权图邻接表实现* {@link listprimandkruskal#listprimandkruskal(e[], edge[])} 构建无向加权图* {@link listprimandkruskal#dfs()} 深度优先遍历无向加权图* {@link listprimandkruskal#bfs()} 广度优先遍历无向加权图* {@link listprimandkruskal#tostring()} 输出无向加权图* {@link listprimandkruskal#prim()} prim算法实现最小生成树* {@link listprimandkruskal#kruskal()} kruskal算法实现最小生成树* {@link listprimandkruskal#getedges()} 获取边集数组** @author lx* @date 2020/5/14 23:31*/public class listprimandkruskal<e> {/*** 顶点类** @param <e>*/private class node<e> {/*** 顶点信息*/e data;/*** 指向第一条依附该顶点的边*/lnode firstlnode;public node(e data, lnode firstlnode) {this.data = data;this.firstlnode = firstlnode;}}/*** 边表节点类*/private class lnode {/*** 该边所指向的顶点的索引位置*/int vertex;/*** 该边的权值*/int weight;/*** 指向下一条边的指针*/lnode nextlnode;}/*** 边对象,具有权值,在构建加权无向图时使用*/private static class edge<e> {private e from;private e to;private int weight;public edge(e from, e to, int weight) {this.from = from;this.to = to;this.weight = weight;}@overridepublic string tostring() {return "edge{" +"from=" + from +", to=" + to +", weight=" + weight +'}';}}/*** 顶点数组*/private node<e>[] vertexs;/*** 边数组*/private edge<e>[] edges;/*** 由于是加权图,这里设置一个边的权值上限,任何边的最大权值不能大于等于该值，在实际应用中，该值应该根据实际情况确定*/private static final int no_edge = 99;/*** 创建无向加权图** @param vexs 顶点数组* @param edges 边二维数组*/public listprimandkruskal(e[] vexs, edge<e>[] edges) {this.edges = edges;/*初始化顶点数组,并添加顶点*/vertexs = new node[vexs.length];for (int i = 0; i < vertexs.length; i++) {vertexs[i] = new node<>(vexs[i], null);}/*初始化边表,并添加边节点到边表尾部,即采用尾插法*/for (edge<e> edge : edges) {// 读取一条边的起始顶点和结束顶点索引值int p1 = getposition(edge.from);int p2 = getposition(edge.to);int weight = edge.weight;/*这里需要相互添加边节点,无向图可以看作相互可达的有向图*/// 初始化lnode1边节点lnode lnode1 = new lnode();lnode1.vertex = p2;lnode1.weight = weight;// 将lnode链接到"p1所在链表的末尾"if (vertexs[p1].firstlnode == null) {vertexs[p1].firstlnode = lnode1;} el {linklast(vertexs[p1].firstlnode, lnode1);}// 初始化lnode2边节点lnode lnode2 = new lnode();lnode2.vertex = p1;lnode2.weight = weight;// 将lnode2链接到"p2所在链表的末尾"if (vertexs[p2].firstlnode == null) {vertexs[p2].firstlnode = lnode2;} el {linklast(vertexs[p2].firstlnode, lnode2);}}}/*** 获取某条边的某个顶点所在顶点数组的索引位置** @param e 顶点的值* @return 所在顶点数组的索引位置, 或者-1 - 表示不存在*/private int getposition(e e) {for (int i = 0; i < vertexs.length; i++) {if (vertexs[i].data == e) {return i;}}return -1;}/*** 将lnode节点链接到边表的最后,采用尾插法** @param first 边表头结点* @param node 将要添加的节点*/private void linklast(lnode first, lnode node) {while (true) {if (first.vertex == node.vertex) {return;}if (first.nextlnode == null) {break;}first = first.nextlnode;}first.nextlnode = node;}@overridepublic string tostring() {stringbuilder stringbuilder = new stringbuilder();for (int i = 0; i < vertexs.length; i++) {stringbuilder.append(i).append("(").append(vertexs[i].data).append("): ");lnode node = vertexs[i].firstlnode;while (node != null) {stringbuilder.append(node.vertex).append("(").append(vertexs[node.vertex].data).append("-").append(node.weight).append(")");node = node.nextlnode;if (node != null) {stringbuilder.append("->");} el {break;}}stringbuilder.append("\n");}return stringbuilder.tostring();}/*** 深度优先搜索遍历图的递归实现,类似于树的先序遍历* 因此模仿树的先序遍历,同样借用栈结构,这里使用的是方法的递归,隐式的借用栈** @param i 顶点索引* @param visited 访问标志数组*/private void dfs(int i, boolean[] visited) {//索引索引标记为true ,表示已经访问了visited[i] = tru下垫面是什么e;system.out.print(vertexs[i].data + " ");//获取该顶点的边表头结点lnode node = vertexs[i].firstlnode;//循环遍历该顶点的邻接点,采用同样的方式递归搜索while (node != null) {if (!visited[node.vertex]) {dfs(node.vertex, visited);}node = node.nextlnode;}}/*** 深度优先搜索遍历图,类似于树的前序遍历,*/public void dfs() {//新建顶点访问标记数组,对应每个索引对应相同索引的顶点数组中的顶点boolean[] visited = new boolean[vertexs.length];//初始化所有顶点都没有被访问for (int i = 0; i < vertexs.length; i++) {visited[i] = fal;}system.out.println("dfs: ");/*循环搜索*/for (int i = 0; i < vertexs.length; i++) {//如果对应索引的顶点的访问标记为fal,则搜索该顶点if (!visited[i]) {dfs(i, visited);}}/*走到这一步,说明顶点访问标记数组全部为true,说明全部都访问到了,深度搜索结束*/system.out.println();}/*** 广度优先搜索图,类似于树的层序遍历* 因此模仿树的层序遍历,同样借用队列结构*/public void bfs() {// 辅组队列queue<integer> indexlinkedlist = new linkedlist<>();//新建顶点访问标记数组,对应每个索引对应相同索引的顶点数组中的顶点boolean[] visited = new boolean[vertexs.length];//初始化所有顶点都没有被访问for (int i = 0; i < vertexs.length; i++) {visited[i] = fal;}system.out.println("bfs: ");for (int i = 0; i < vertexs.length; i++) {//如果访问方剂为fal,则设置为true,表示已经访问,然后开始访问if (!visited[i]) {visited[i] = true;system.out.print(vertexs[i].data + " ");indexlinkedlist.add(i);}//判断队列是否有值,有就开始遍历if (!indexlinkedlist.impty()) {//出队列integer j = indexlinkedlist.poll();lnode node = vertexs[j].firstlnode;while (node != null) {int k = node.vertex;if (!visited[k]) {visited[k] = true;system.out.print(vertexs[k].data + " ");//继续入队列indexlinkedlist.add(k);}node = node.nextlnode;}}}system.out.println();}/*** prim算法求最小生成树*/public void prim() {system.out.println("prim: ");//对应节点应该被连接的前驱节点,用来输出//默认为0,即前驱结点为第一个节点int[] mid = new int[vertexs.length];int start = 0;int min, tmp, sum = 0;int num = vertexs.length;//顶点间边的权值//存储未连接顶点到已连接顶点的最短距离(最小权)int[] dis = new int[num];// 初始化"顶点的权值数组"，// 将每个顶点的权值初始化为"第start个顶点"到"该顶点"的权值。//首先将其他顶点到0索引顶点的权值存储进去for (int i = 0; i < num; i++) {dis[i] = getweight(start, i);}//如果某顶点作为末端顶点被连接，对应位置应该为true//第一个顶点默认被连接boolean[] connected = new boolean[vertexs.length];connected[0] = true;/*默认第一个顶点已经找到了,因此最多还要需要大循环n-1次*/for (int k = 1; k < num; k++) {min = no_edge;//最小权值的顶点的索引int minindex = 0;// 在未被加入到最小生成树的顶点中，找出权值最小的顶点。for (int i = 1; i < vertexs.length; i++) {//排除已连接的顶点,排除权值等于0的值,因为这里默认顶点指向自己的权值为0if (!connected[i] && dis[i] != 0 && dis[i] < min) {min = dis[i];minindex = i;}}//如果没找到,那么该图可能不是连通图,直接返回了,此时最小生成树没啥意义if (minindex == 0) {return;}//权值和增加sum += min;//该新连接顶点对应的索引值变成true,表示已被连接,后续判断时跳过该顶点connected[minindex] = true;//输出四字好词500个对应的前驱顶点到该最小顶点的权值system.out.println(vertexs[mid[minindex]].data + " ---> " + vertexs[minindex].data + " 权值:" + min);/*在新顶点minindex加入之前的其他所有顶点到连接顶点最小的权值已经计算过了因此只需要更新其他顶点到新连接顶点minindex是否还有更短的权值,有的话就更新找到距离已连接的顶点权最小的顶点*/for (int i = 1; i < num; i++) {//如果该顶点未连接if (!connected[i]) {// 获取minindex顶点到未连接顶点i的权值tmp = getweight(minindex, i);/*如果新顶点到未连接顶点i的权值不为0,并且比原始顶点到未连接顶点i的权值还要小,那么更新对应位置的最小权值*/if (tmp != 0 && dis[i] > tmp) {dis[i] = tmp;//更新前驱节点索引为新加入节点索引mid[i] = minindex;}}}}system.out.println("sum: " + sum);}/*** 尝试获取边起点start到边终点end的边的权值,当然可能获取不到** @param start 边起点* @param end 边终点* @return 返回权值; 如果起点和终点相同则返回0;如果边起点和边终点之间并没有边, 则返回no_edge*/private int getweight(int start, int end) {//如果start=end，则返回0if (start == end) {return 0;}//获取该顶点的边表的第一个值lnode node = vertexs[start].firstlnode;//循环查找边表,看能否找到对应的索引=end,找不到就返回no_edge,表示两个顶点未连接。while (node != null) {if (end == node.vertex) {return node.weight;}node = node.nextlnode;}return no_edge;}/*** kruskal算法求最小生成树,可以说邻接矩阵和邻接链表的实现方式是完全一致的*/public void kruskal() {//由于创建图的时候保存了边集数组,这里直接使用就行了//edge[] edges = getedges();//this.edges=edges;//对边集数组进行排序arrays.sort(this.edges, comparator.comparingint(o -> o.weight));// 用于保存已有最小生成树中每个顶点在该最小树中的最终终点的索引int[] vends = new int[this.edges.length];//能够知道终点索引范围是[0,this.edges.length-1],因此填充edges.length表示没有终点arrays.fill(vends, this.edges.length);int sum = 0;for (edge<e> edge : this.edges) {// 获取第i条边的起点索引fromint from = getposition(edge.from);// 获取第i条边的终点索引toint to = getposition(edge.to);// 获取顶点from在"已有的最小生成树"中的终点int m = getendindex(vends, from);// 获取顶点to在"已有的最小生成树"中的终点int n = getendindex(vends, to);// 如果m!=n，意味着没有形成环路,则可以添加,否则直接跳过,进行下一条边的判断if (m != n) {//添加设置原始终点索引m在已有的最小生成树中的终点为nvends[m] = n;system.out.println(vertexs[from].data + " ---> " + vertexs[to].data + " 权值:" + edge.weight);sum += edge.weight;}}system.out.println("sum: " + sum);//system.out.println(arrays.tostring(this.edges));}/*** 获取顶点索引i的终点如果没有终点则返回顶点索引本身** @param vends 顶点在最小生成树中的终点* @param i 顶点索引* @return 顶点索引i的终点如果没有终点则返回顶点索引本身*/private int getendindex(int[] vends, int i) {//这里使用循环查找的逻辑,寻找的是最终的终点while (vends[i] != this.edges.length) {i = vends[i];}return i;}/*** 如果没有现成的边集数组，那么根据邻接表结构获取图中的边集数组** @return 图的边集数组*/private edge[] getedges() {list<edge> edges = new arraylist<>();//遍历顶点数组for (int i = 0; i < vertexs.length; i++) {lnode node = vertexs[i].firstlnode;while (node != null) {//只需添加起点索引小于终点索引的边就行了if (node.vertex > i) {edges.add(new edge<>(vertexs[i].data, vertexs[node.vertex].data, node.weight));}node = node.nextlnode;}}return edges.toarray(new edge[0]);}public static void main(string[] args) {//顶点数组character[] vexs = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};//边数组,加权值edge[] edges = {new edge('a', 'c', 1),new edge('d', 'a', 2),new edge('a', 'f', 3),new edge('b', 'c', 4),new edge('c', 'd', 5),new edge('e', 'g', 6),new edge('e', 'b', 7),new edge('d', 'b', 8),new edge('f', 'g', 9)};//构建图listprimandkruskal<character> listprimandkruskal = new listprimandkruskal<character>(vexs, edges);//输出图system.out.println(listprimandkruskal);//深度优先遍历//dfs://a c b e g f dlistprimandkruskal.dfs();//广度优先遍历//bfs://a c d f b g elistprimandkruskal.bfs();//prim算法求最小生成树listprimandkruskal.prim();//kruskal算法求最小生成树listprimandkruskal.kruskal();//获取边集数组edge[] edges1 = listprimandkruskal.getedges();system.out.println(arrays.tostring(edges1));}}最小生成树能够有效的解决生活中的最小经费问题，但是有一部分问题却不能解决，比如求两个不直接相通的站点之间的最短通行时间问题，这里求的就不是最小生成树了，因为不需要连通所有站点，而是只需要最短通行时间路径，即最短路径。
以上就是java求最小生成树的两种算法详解的详细内容，更多关于java最小生成树的资料请关注www.887551.com其它相关文章！
本文发布于:2023-04-04 18:27:35，感谢您对本站的认可！
本文链接：https://www.wtabcd.cn/fanwen/zuowen/1620f3423c1a44e086ceb88ec38fa5e8.html
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系，我们将在24小时内删除。
本文word下载地址：Java求最小生成树的两种算法详解.doc
本文 PDF 下载地址：Java求最小生成树的两种算法详解.pdf
| 留言与评论（共有 0 条评论） |
