图的相关算法总结

最新推荐文章于 2024-07-26 13:09:36 发布

suprefan

最新推荐文章于 2024-07-26 13:09:36 发布

阅读量223

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/waiter123321/article/details/116401454

版权

本文总结了图的相关算法，包括Prim算法和Kruskal算法解决最小生成树问题，以及Dijkstra算法和Floyd算法用于求解最短路径问题。Prim算法通过贪心策略从一个顶点逐步构建最小生成树，而Kruskal算法则按边的权重从小到大选择边。Dijkstra算法每次选择离出发点最近的未标记节点，并更新其邻近节点的距离，Floyd算法通过迭代检查所有节点对之间的最短路径。

摘要由CSDN通过智能技术生成

1.最小生成树

Prim算法：基于顶点的一种贪心思路。从一个顶点开始，并且标记该顶点已被访问visited = 1，然后在与之有边的且未标记过的顶点中，选择权最小的那个顶底并标记，记录下该边的权。重复上面操作，（若有N个顶点）直到有N-1条边时，遍历完成。

public class Prim {
   
    final static int N = 10000;
    public static void main(String[] args) {
   
        char[] data = new char[]{
   'A','B','C','D','E','F','G'};
        int verx = data.length;

        int[][] weight = new int[][]{
   
                {
   N, 5, 7, N, N, N, 2},
                {
   5, N, N, 9, N, N, 3},
                {
   7, N, N, N, 8, N, N},
                {
   N, 9, N, N, N, 4, N},
                {
   N, N, 8, N, N, 5, 4},
                {
   N, N, N, 4, 5, N, 6},
                {
   2, 3, N, N, 4, 6, N}
        };
        Graph graph = new Graph(verx);
        MinTree minTree = new MinTree();
        minTree.createGraph(graph, verx, data, weight);
//        minTree.show(graph);
        minTree.prim(graph, 4);
    }

    static class MinTree {
   
        //创建邻接矩阵
        public void createGraph(Graph graph, int verx, char[] data, int[][] weight) {
   
            int i, j;
            for (i = 0; i < verx; i++) {
   
                graph.data[i] = data[i];
                for(j = 0; j < verx; j++){
   
                    graph.weight[i][j] = weight[i][j];
                }
            }
        }

        //显示图的方法
        public void show(Graph graph){
   
            for(int[] link : graph.weight){
   
                System.out.println(Arrays.toString(link));
            }
        }

        public void prim(Graph graph, int v){
   
            int[] visited = new int[graph.verx];
            visited[v] = 1;
            int h1 = -1;
            int h2 = -1;
            int min = N;
            for(int k = 1; k < graph.verx; k++){
   
                for (int i = 0; i < graph.verx; i++){
   
                    for(int j = 0; j < graph.verx; j++){
   
                        if(visited[i] == 1 && visited[j] == 0 && graph.weight[i][j] < min) {
   
                            min = graph.weight[i][j];
                            h1 = i;
                            h2 = j;
                        }
                    }
                }
                System.out.println("边<" + graph.data[h1] + "," + graph.data[h2] + "> 权值:" + min);
                visited[h2] = 1;
                min = N;
            }
        }
    }

    static class Graph {
   
        int verx; //节点个数
        char[] data; //存放节点数据