Java数据结构与算法——最小生成树

最新推荐文章于 2024-07-26 12:28:02 发布
最新推荐文章于 2024-07-26 12:28:02 发布
阅读量2.1k 收藏 23
点赞数 3
分类专栏： 数据结构与算法 文章标签： java 图论 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cm15835106905/article/details/124655599
版权

一、关于图的几个概念定义：

  • 连通图：在无向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该无向图为连通图。
  • 强连通图：在有向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该有向图为强连通图。
  • 连通网：在连通图中，若图的边具有一定的意义，每一条边都对应着一个数，称为权；权代表着连接连个顶点的代价，称这种连通图叫做连通网。
  • 生成树：一个连通图的生成树是指一个连通子图，它含有图中全部n个顶点，但只有足以构成一棵树的n-1条边。一颗有n个顶点的生成树有且仅有n-1条边，如果生成树中再添加一条边，则必定成环。

二、最小生成树基础知识：

1、定义：

最小生成树：在连通网的所有生成树中，所有边的代价和最小的生成树，称为最小生成树。简单说就是在一个连通图上创建一棵树，使这棵树能遍历所以结点，且路径值最小，且树不能有环，这样的树叫最小生成树。

2、特点：

  • 没有环
  • 任意2个顶点都是互通的
  • n顶点，n-1条边

3、示例：

有连通图如下：
在这里插入图片描述
生成的最小生成树就下图中的红色边：
在这里插入图片描述

4、最小生成树使用场景

最小生成树一般可用于求解最短路径问题，场景有城市、网络等。连通图中连接所有点且权值最小。

三、最小生成树算法

通常来说，要解决最小生成树问题，通常采用两种算法：Prim算法和Kruskal算法

1、Prim(普里姆)算法

此算法可以称为“加点法”，每次迭代选择代价最小的边对应的点，加入到最小生成树中。算法从某一个顶点s开始，逐渐长大覆盖整个连通网的所有顶点。

具体步骤如下：

  1. 图的所有顶点集合为V；初始令集合u={s},v=V−u;
  2. 在两个集合u,v能够组成的边中，选择一条代价最小的边(u0,v0)，加入到最小生成树中，并把v0并入到集合u中。
  3. 重复上述步骤，直到最小生成树有n-1条边或者n个顶点为止。

假设起点为A
在这里插入图片描述
其它剩余点到集合u的最小边，A->C，C加入u集合
在这里插入图片描述
其它剩余点到集合u的最小边，C->D，D加入u集合

在这里插入图片描述
由此类推，得出最小生成树
在这里插入图片描述

2、Kruskal(克鲁斯卡尔)算法

此算法可以称为“加边法”，初始最小生成树边数为0，每迭代一次就选择一条满足条件的最小代价边，加入到最小生成树的边集合里。

具体步骤如下：

  1. 把图中的所有边按代价从小到大排序；
  2. 把图中的n个顶点看成独立的n棵树组成的森林；
  3. 按权值从小到大选择边，若形成环，不选，所选的边连接的两个顶点ui,vi，应属于两颗不同的树，则成为最小生成树的一条边，并将这两颗树合并作为一颗树。
  4. 重复(3),直到所有顶点都在一颗树内或者有n-1条边为止。
    在这里插入图片描述

四、代码实现

代码采用的算法思想是Kruskal算法

1、图的边类

public class Edge {
    /**
    * 连接该条边的一个结点
    */
    private EdgeNode edgeNode1;
    /**
    * 连接该条边的另一个结点
    */
    private EdgeNode edgeNode2;
    /**
    * 该边的权值
    */
    private int weight;

    public Edge(EdgeNode edgeNode1, EdgeNode edgeNode2, int weight) {
        this.edgeNode1 = edgeNode1;
        this.edgeNode2 = edgeNode2;
        this.weight = weight;
    }

    public EdgeNode getEdgeNode1() {
        return edgeNode1;
    }

    public void setEdgeNode1(EdgeNode edgeNode1) {
        this.edgeNode1 = edgeNode1;
    }

    public EdgeNode getEdgeNode2() {
        return edgeNode2;
    }

    public void setEdgeNode2(EdgeNode edgeNode2) {
        this.edgeNode2 = edgeNode2;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }
}

2、节点类

public class EdgeNode {
	/**
    * 节点名称
    */
    private String nodeName;

    public String getNodeName() {
        return nodeName;
    }

    public void setNodeName(String nodeName) {
        this.nodeName = nodeName;
    }

    public EdgeNode(String nodeName) {
        this.nodeName = nodeName;
    }
}

3、具体算法类

public class Solution {

   private   ArrayList<Edge> list=new ArrayList<>();
   private   HashMap<String,EdgeNode> nodeMap=new HashMap<>();

   /**
     * 构件图
     * @param node1
     * @param node2
     * @param weight
     */
   public void createMGraph(String node1,String node2,int weight){
         EdgeNode edgeNode1 = nodeMap.get(node1);
         EdgeNode edgeNode2 = nodeMap.get(node2);
         // 如果点不存在,则新构建一个点,如果存在就使用存在的点
         if (edgeNode1==null) {
             edgeNode1 = new EdgeNode(node1);
             nodeMap.put(node1,edgeNode1);
         }
         if (edgeNode2==null){
             edgeNode2 = new EdgeNode(node2);
             nodeMap.put(node2,edgeNode2);
         }
         list.add(new Edge(edgeNode1,edgeNode2,weight));

     }

    public void miniTree(){
         String nodeName1, nodeName2;
         // 用于存放最小生成树的边
         Map<String,String> map =new HashMap<>();
         // 将图中的所有边按权重从小到大排序
         list.sort(Comparator.comparingInt(Edge::getWeight));
         for (int i = 0,j=1; i <list.size() ; i++) {
             nodeName1=find(map,list.get(i).getEdgeNode1().getNodeName());
             nodeName2=find(map,list.get(i).getEdgeNode2().getNodeName());
             if (!nodeName1.equals(nodeName2)){
             	 // 两个点不相等,记录这一条边
                 map.put(nodeName1,nodeName2);
                 // 得到路径
                 System.out.println("路径"+j++ +":"+"开始结点："+list.get(i).getEdgeNode1().getNodeName()
                                   +";结束结点："+list.get(i).getEdgeNode2().getNodeName()+";权值："+list.get(i).getWeight());
             }
         }

     }
     /**
     * 该方法用于判断两个结点连接后是否会形成环
     * @param map 已经遍历过的节点集合
     * @param nodeName 将要遍历的节点名称
     * @return
     */
     private String find(Map<String ,String > map,String nodeName){
     	// 循环找到没有遍历过的点
         while (map.get(nodeName)!=null){
             nodeName=map.get(nodeName);
         }
         return nodeName;
     }
}

4、测试类

构建如下的图
在这里插入图片描述

public class Test {
    public static void main(String[] args) {

        Solution t=new Solution();
        //构造以上的例图
        t.createMGraph("V0","V1",10);
        t.createMGraph("V0","V5",11);
        t.createMGraph("V1","V2",18);
        t.createMGraph("V1","V8",12);
        t.createMGraph("V1","V6",16);
        t.createMGraph("V2","V8",8);
        t.createMGraph("V2","V3",22);
        t.createMGraph("V3","V8",21);
        t.createMGraph("V3","V6",24);
        t.createMGraph("V3","V7",16);
        t.createMGraph("V3","V4",20);
        t.createMGraph("V4","V7",7);
        t.createMGraph("V4","V5",26);
        t.createMGraph("V5","V6",17);
        t.createMGraph("V6","V7",19);

        t.miniTree();
    }
}

5、结果

路径1:开始结点：V4;结束结点：V7;权值：7
路径2:开始结点：V2;结束结点：V8;权值：8
路径3:开始结点：V0;结束结点：V1;权值：10
路径4:开始结点：V0;结束结点：V5;权值：11
路径5:开始结点：V1;结束结点：V8;权值：12
路径6:开始结点：V1;结束结点：V6;权值：16
路径7:开始结点：V3;结束结点：V7;权值：16
路径8:开始结点：V6;结束结点：V7;权值：19

即生成的最小生成树为
在这里插入图片描述

五、场景案例题目实战

1、题目

在这里插入图片描述

2、代码

import java.util.*;


public class Solution {
    /**
     * 存图的边
     */
    private static ArrayList<Edge> list = new ArrayList<>();
    /**
     * 存图的节点
     */
    private static HashMap<Integer, EdgeNode> nodeMap = new HashMap<>();
    
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 返回最小的花费代价使得这n户人家连接起来
     * @param n int n户人家的村庄
     * @param m int m条路
     * @param cost int二维数组 一维3个参数，表示连接1个村庄到另外1个村庄的花费的代价
     * @return int
     */
    public int miniSpanningTree (int n, int m, int[][] cost) {
        // write code here
        Solution t = new Solution();
        for (int i = 0; i < cost.length; i++) {
            int[] edge = cost[i];
            t.createGraph(edge[0],edge[1],edge[2]);
        }
        return getMiniTree();
    }
    
    /**
     * 构件图
     * @param node1
     * @param node2
     * @param weight
     */
    public void createGraph(int node1, int node2, int weight) {
        // 如果点不存在,则新构建一个点,如果存在就使用存在的点
        EdgeNode edgeNode1 = nodeMap.get(node1);
        EdgeNode edgeNode2 = nodeMap.get(node2);
        if(edgeNode1 == null){
            edgeNode1 = new EdgeNode(node1);
            nodeMap.put(node1,edgeNode1);
        }
        if(edgeNode2 == null){
            edgeNode2 = new EdgeNode(node2);
            nodeMap.put(node2,edgeNode2);
        }

        Edge edge = new Edge(edgeNode1,edgeNode2,weight);
        list.add(edge);
    }

    public Integer getMiniTree() {
        // 将图中的所有边按权重从小到大排序
        list.sort(Comparator.comparingInt(Edge::getWeight));
        Map<Integer,Integer> nodeMap = new HashMap<>(16);
        int result = 0;
        Integer nodeName1,nodeName2;
        for (int i = 0,j = 1; i < list.size(); i++) {
            nodeName1 = find(nodeMap,list.get(i).getEdgeNode1().getNodeName());
            nodeName2 = find(nodeMap,list.get(i).getEdgeNode2().getNodeName());
            if(!nodeName1.equals(nodeName2)){
                // 两个点不相等,记录这一条边
                nodeMap.put(nodeName1,nodeName2);
                result += list.get(i).getWeight();
            }
        }
        return result;
    }

    /**
     * 该方法用于判断两个结点连接后是否会形成环
     * @param map 已经遍历过的节点集合
     * @param nodeName 将要遍历的节点名称
     * @return
     */
    private Integer find(Map<Integer, Integer> map, Integer nodeName) {
        // 循环直到没有遍历过的点
        while(map.get(nodeName) != null){
            nodeName = map.get(nodeName);
        }
        return nodeName;
    }
}

class Edge {
    private EdgeNode edgeNode1;
    private EdgeNode edgeNode2;
    private int weight;

    public Edge(EdgeNode edgeNode1, EdgeNode edgeNode2, int weight) {
        this.edgeNode1 = edgeNode1;
        this.edgeNode2 = edgeNode2;
        this.weight = weight;
    }

    public EdgeNode getEdgeNode1() {
        return edgeNode1;
    }

    public void setEdgeNode1(EdgeNode edgeNode1) {
        this.edgeNode1 = edgeNode1;
    }

    public EdgeNode getEdgeNode2() {
        return edgeNode2;
    }

    public void setEdgeNode2(EdgeNode edgeNode2) {
        this.edgeNode2 = edgeNode2;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }
}

class EdgeNode {
    private Integer nodeName;

    public Integer getNodeName() {
        return nodeName;
    }

    public void setNodeName(Integer nodeName) {
        this.nodeName = nodeName;
    }

    public EdgeNode(Integer nodeName) {
        this.nodeName = nodeName;
    }
}
梦想不会灭
关注
  • 3
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构&算法——Java.zip
01-14
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
算法和数据结构——左程云.zip
01-15
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
JAVA数据结构与算法之————最小生成树
qq_36007633的博客
04-29 420
Kruskal算法和Prim算法 Kruskal Kruskal算法是用来计算加权连通图的最小生成树的算法。 基本思想:按照权值从小到大的顺序选择n-1条边，并保证这n-1条边不构成回路。 边结构： public static class Edge{ int begin; int end; int weight; public Edg...
数据结构(最小生成树)
2301_76492964的博客
05-31 685
1.prim算法和kruskai算法生成最小树中prim对应的是点，因此prim使用于稠密图的最小生成树运算；kruskal对应的是边，因此kruskal算法使用于稀疏图。2.prim的时间复杂度为,kruskal的时间复杂度为3.prim算法执行时由于其特性不会检查回路，但kruskal是对应边构造最小生成树，因此后者需要对构造的最小生成树检查回路，可引入并查集。图的内容比较深奥，循序渐进即可 本人所写代码有误但有参考意义，图示解决疑惑是我的一点特色。
贪心算法与数据结构结合2——最小生成树问题：Prim算法
qq_41926985的博客
04-23 789
我曾经听说过很多人的梦想，但由于时间的消磨。这些梦想也就慢慢消退了； 我也听说过很多人侃侃而谈，最后却只是谈了谈而已。 人基本都是这样的，肯定都有梦想，但就是碍于时间和精力以及周遭变化原因未能继续追寻，继续前进了。 所以，如果你还想奋斗，还想追寻那种美好的憧憬。请一定要坚持下去，不要放弃！ 本篇是贪心算法与数据结构结合的第二篇，本篇主要介绍最小生成树问题和以及解最小生成树问题的贪心算法——Pri...
Java算法学习9——最小生成树之Kruskal算法
Warddamn的博客
03-13 2607
一、Krusal算法简介 Krusal算法其实就是以边为主，每次都选择权重最小的并且两个端点不在同一个连通分量的那条边加进生成树T中，知道T的边达到了顶点数-1之后，就暂停。所以，可以先将边按从小到大进行排序，然后再去选取每一条边，判断它的两个端点是否是同一连通分量 二、Krusal算法实现步骤 输入格式：第一行有两个整型数，第一个数为顶点数，第二个数为边数N，接下来就要N行，每一行有3个字符，第一个为字母就是起点，第二个字母是终点，第三个数字是权重。 输出格式：输出一个整数，表示最小生成树的权重和 实现步
数据结构与算法—最小生成树(Prim算法和Kruskal算法算法详解)
热门推荐
bigsai
10-18 1万+
在图论中，最小生成树也是一种常用算法，本文将从一些有趣的例子和来讲诉最小生成树的prim算法和kruskal算法。中间也夹杂了马克思主义理论，！
Java数据结构——图：最小生成树(克鲁斯卡尔算法Kruskal)
2302_77261297的博客
07-06 868
上一步操作之后，边的权值最小，但会和已有的边构成回路；将边加入到最小生成树结果 R 中。上一步操作之后，边的权值最小，但会和已有的边构成回路；上一步操作之后，边的权值最小，因此将它加入到最小生成树结果 R 中。上一步操作之后，边的权值最小，因此将它加入到最小生成树结果 R 中。上一步操作之后，边的权值最小，因此将它加入到最小生成树结果 R 中。边的权值最小，因此将它加入到最小生成树结果 R 中。
[Java学习] 最小生成树——Prim算法
Admzy的博客
12-17 2895
文章目录最小生成树Prim算法流程应用实例求最小生成树 最小生成树 百度百科上对于最小生成树的定义是这样的：一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。 通俗的解释最小生成树包括以下两点：(1) 最小；(2) 树。 对于树的概念，必须满足以下两条性质： （1）图中没有任何环； （2）必须连接所有顶点且都是互通的； 故，对于一个有N个顶点的树，他有N-1条边。 接下来是最小。一个图会有若干个生成树，我们把这些生成树边的权值相加称为权值.
图——最小生成树实现(Kruskal算法,prime算法)
2301_80035594的博客
02-22 1806
介绍最少生成树的概念及并查集的实现接着解释Kruskal算法和Prime算法的原理（配合图），并实现其代码并进行测试。
最小生成树——Kruskal算法
小天狼星_布莱克 的博客
08-11 1143
KruskalKruskalKruskal算法是一种用于解决最小生成树问题的贪心算法。最小生成树问题是指在一个连通图中找到一棵包含所有顶点的树，且树的边权重之和最小。KruskalKruskalKruskal算法的基本思想是从图中的边集合中选择权重最小的边，并且保证选择的边不会构成环，直到选择了n−1n-1n−1条边为止（nnn为图中顶点的个数）。
贪心算法：最小生成树Prim算法
一个专注于客户端开发的技术er，不定期更新Android，Flutter，HormonyOS等方向的使用心得和感悟
05-31 6584
这是大一暑假的c笔记，再一次写prim算法笔记又有一点点进步最小生成树（Prim普利姆算法和Kruskal算法）
数据结构与算法答案——java语言描述
02-08
7. **图算法**：Dijkstra算法、Floyd算法、Kruskal算法、Prim算法等，用于解决最短路径问题、最小生成树问题等。 8. **递归与分治**：递归是解决问题的一种重要方法，如计算阶乘、遍历树结构等。分治策略如归并排序...
数据结构与算法分析Java3rd英文_数据结构与算法分析_
10-03
8. **图论算法**：包括遍历（深度优先搜索和广度优先搜索）、最短路径（Dijkstra算法、Floyd-Warshall算法）和最小生成树（Prim算法、Kruskal算法）等，应用于网络规划、社交网络分析等领域。 9. **算法分析**：...
Java语言的数据结构与算法书
07-25
图论算法，如最短路径算法（Dijkstra、Floyd-Warshall）和最小生成树算法（Prim、Kruskal），在网络优化和资源分配等领域有广泛应用。 此外，书中可能还会涉及哈希表，这是一种能提供快速查找和插入的数据结构，其...
golang 接口
m0_70982551的博客
07-24 872
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 460
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 566
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值