首页 > 编程语言> 文章详细

kruskal算法和prim算法

2021-08-13 19:02:16 阅读：241 来源： 互联网

标签：distances prim int graph kruskal 生成算法 new size

1、两种算法都针对无向图
2、目的：生成最小生成树

生成树：一个连通图的生成树是指一个连通子图，它含有图中全部n个顶点，但只有足以构成一棵树的n-1条边。

一颗有n个顶点的生成树有且仅有n-1条边，如果生成树中再添加一条边，则必定成环。

最小生成树：在连通网的所有生成树中，所有边的代价和最小的生成树，称为最小生成树。

相关知识参考

一、Kruska算法

1.将图中的所有边按权值从小到大排序；
2.把图中的n个顶点看成独立的n棵树组成的森林；
3.按权值从小到大选择边，所选的边连接的两个顶点ui，vi应属于两颗不同的树，则成为最小生成树的一条边，然后将这两颗树合并作为一颗树。
4.重复（3），直到所有顶点都在一颗树内或者有n-1条边为止。

Kruskal算法

二、prim算法

此算法可以称为“加点法”，每次迭代选择代价最小的边对应的点，

代码实现

package Algorithms.Graph;


import java.util.Comparator;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Set;

// undirected graph only
public class Prim {

    public static class EdgeComparator implements Comparator<Edge> {

        @Override
        public int compare(Edge o1, Edge o2) {
            return o1.weight - o2.weight;
        }
    }

    public static Set<Edge> primMST(Graph graph) {

        PriorityQueue<Edge> priorityQueue = new PriorityQueue<>(
                new EdgeComparator()); //优先级队列：用来存放解锁的边
        HashSet<Node> set = new HashSet<>();
        Set<Edge> result = new HashSet<>(); //用来存放依次挑选的边

        for (Node node : graph.nodes.values()) { //随便挑一个点，for循环是为了处理森林的问题
            //node是开始点                             如果一个图是连通图，就不需要for循环
            if (!set.contains(node)) {
                set.add(node);
                for (Edge edge : node.edges) { //由一个点，解锁所有相连的边
                    priorityQueue.add(edge); //把这个点所有的边放入优先级队列中
                }
                while (!priorityQueue.isEmpty()) {
                    Edge edge = priorityQueue.poll(); //从优先级队列中取一个边（value值最小的边）
                    Node toNode = edge.to;   //拿到这个边所指向的Node
                    if (!set.contains(toNode)) { // 如果这个Node不再set集合中，就是一个新Node
                        set.add(toNode);
                        result.add(edge);
                        for (Edge nextEdge : toNode.edges) { //然后再把这个新Node所有的边放入优先级队列中
                            priorityQueue.add(nextEdge);
                        }
                        //以上代码可能会把重复的边扔到优先级队列中，但不影响结果（会被if条件直接跳过）
                    }
                }
            }
        }
        return result;
    }

    // 请保证graph是连通图
    // graph[i][j]表示点i到点j的距离，如果是系统最大值代表无路
    // 返回值是最小连通图的路径之和
    public static int prim(int[][] graph) {
        int size = graph.length;
        int[] distances = new int[size];
        boolean[] visit = new boolean[size];
        visit[0] = true;
        for (int i = 0; i < size; i++) {
            distances[i] = graph[0][i];
        }
        int sum = 0;
        for (int i = 1; i < size; i++) {
            int minPath = Integer.MAX_VALUE;
            int minIndex = -1;
            for (int j = 0; j < size; j++) {
                if (!visit[j] && distances[j] < minPath) {
                    minPath = distances[j];
                    minIndex = j;
                }
            }
            if (minIndex == -1) {
                return sum;
            }
            visit[minIndex] = true;
            sum += minPath;
            for (int j = 0; j < size; j++) {
                if (!visit[j] && distances[j] > graph[minIndex][j]) {
                    distances[j] = graph[minIndex][j];
                }
            }
        }
        return sum;
    }

    public static void main(String[] args) {
        System.out.println("hello world!");
    }

}

标签：distances,prim,int,graph,kruskal,生成,算法,new,size
来源： https://www.cnblogs.com/zh-xiaoyuan/p/15138504.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

kruskal算法和prim算法