【算法基础实验】图论-构建加权无向图

于 2024-04-27 13:02:46 发布
阅读量1.1k 收藏 10
点赞数 17
文章标签： 算法 图论 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33868661/article/details/138247248
版权

构建加权无向图

理论基础

在图论中，加权无向图是一种每条边都分配了一个权重或成本的图形结构。这种类型的图在许多实际应用中都非常有用，如路由算法、网络流量设计、最小生成树和最短路径问题等。

加权无向图的基本特征

  1. 顶点和边：
    • 顶点（Vertex）: 图中的节点，可以表示交叉点、位置点或网络中的节点等。
    • 边（Edge）: 连接顶点的线，无向边意味着连接的顶点间没有方向性的区别。
  2. 权重：
    • 每条边都有一个权重（或成本、长度），这个权重是一个数值，代表了从一个顶点到另一个顶点的“成本”。
    • 权重可以表示多种含义，如距离、时间、消耗或任何其他度量标准。

存储加权无向图

加权无向图通常可以通过以下几种数据结构来存储和表示：

  1. 邻接矩阵：
    • 使用二维数组来表示顶点之间的连接关系，矩阵中的每个元素代表边的权重。如果两个顶点之间没有直接连接，则该位置通常用一个特殊值（如无穷大或null）来表示。
  2. 邻接表：
    • 每个顶点都对应一个列表，列表中存储了与该顶点直接相连的其他顶点及相应的权重。这种表示方法更加节省空间，尤其是在稀疏图中。
  3. 边的列表：
    • 维护一个所有边的列表，每条边由一对顶点和一个权重组成。

图的操作

操作加权无向图常见的算法包括但不限于：

  1. 最小生成树（MST）：
    • 寻找一种方式，通过树形结构连接图中的所有顶点，使得所有边的权重总和最小。常用算法包括Kruskal算法和Prim算法。
  2. 最短路径：
    • 寻找顶点间的最短路径，即路径上的权重总和最小。常用算法包括Dijkstra算法和Floyd-Warshall算法。
  3. 网络流量优化：
    • 在网络图中，寻找最优的数据流方式，使得成本最低或效率最高。

应用实例

加权无向图的应用非常广泛，例如：

  • 交通网络：道路或铁路网中的路径规划，权重可以是距离、时间或通行费用。
  • 电信网络：数据包的传输路径优化，权重可能是延迟或带宽。
  • 物流配送：货物配送路线的优化，权重可能包括距离和成本。
  • 资源分配：如电网中电力的分配。

加权无向图的研究和应用提供了一种强大的工具，可以解决实际中的许多优化和规划问题。在算法和数据结构的领域中，理解并有效使用这些工具是非常重要的。

数据结构和实验数据

请添加图片描述

代码实现

myEdge

public class myEdge implements Comparable<myEdge>
{
    private final int v;
    private final int w;
    private final double weight;

    public myEdge(int v,int w,double weight){
        this.v = v;
        this.w = w;
        this.weight = weight;
    }
    public double weight()
    {return weight;}

    public int either()
    { return v;}

    public int other(int vertex)
    {
        if(vertex == v) return w;
        else if(vertex == w) return v;
        else throw new IllegalArgumentException("Invalid vertex");
    }
    public int compareTo(myEdge that)
    {
        if(this.weight()<that.weight()) return -1;
        else if(this.weight()>that.weight()) return 1;
        else return 0;
    }
    public String toString()
    { return String.format("%d-%d %.2f",v,w,weight);}
}

这段代码定义了一个名为 myEdge 的类，代表加权无向图中的一条边。类实现了 Comparable 接口，允许边对象之间进行比较，这通常用于算法中需要对边进行排序的情况，例如在构建最小生成树时。以下是对该类中每个部分的详细解释：

类定义和字段


public class myEdge implements Comparable

这段代码定义了一个名为 myEdge 的类，代表加权无向图中的一条边。类实现了 Comparable 接口，允许边对象之间进行比较，这通常用于算法中需要对边进行排序的情况，例如在构建最小生成树时。以下是对该类中每个部分的详细解释：

类定义和字段


public class myEdge implements Comparable

这段代码定义了一个名为 myEdge 的 Java 类，用于表示加权无向图的一条边。这个类实现了 `Comparable

这段代码定义了一个名为 myEdge 的 Java 类，用于表示加权无向图的一条边。这个类实现了 Comparable 接口，使得边可以根据权重进行排序，这是在图算法中常见的需求，特别是在最小生成树和最短路径算法中。

类字段

  • v 和 w：这两个 private final int 类型的字段代表边连接的两个顶点。final 表明一旦边被创建，这两个顶点不可更改。
  • weight：这是一个 private final double 类型的字段，存储边的权重。同样，final 表示权重在创建后不可更改。

构造函数


public myEdge(int v, int w, double weight) {
    this.v = v;
    this.w = w;
    this.weight = weight;
}

构造函数接收两个顶点标识和一个权重，初始化边的基本属性。

方法

  • weight()：返回边的权重。

    
public double weight() { return weight; }

  • either()：返回边的一个顶点。此方法用于访问边的任一端点，通常在边的迭代中使用。

    
public int either() { return v; }

  • other(int vertex)：给定边的一个顶点，返回另一个顶点。如果传入的顶点不是这条边的一部分，抛出 IllegalArgumentException。

    
public int other(int vertex) {
    if (vertex == v) return w;
    else if (vertex == w) return v;
    else throw new IllegalArgumentException("Invalid vertex");
}

  • compareTo(myEdge that)：实现 `Comparable接口的方法，用于比较两条边的权重。这使得边可以被排序，通常用于算法如 Kruskal 的最小生成树算法中。

    
public int compareTo(myEdge that) {
    return Double.compare(this.weight, that.weight);
}

  • toString()：提供边的字符串表示，格式为 “v-w weight”，其中 v 和 w 是顶点标识，weight 是边的权重。这对于打印和调试很有用。

    
public String toString() {
    return String.format("%d-%d %.2f", v, w, weight);
}

总结

myEdge 类提供了一个结构化的方式来表示图中的边，包括边的两个端点和权重。实现 Comparable 接口允许边根据权重进行排序，这在很多图算法中非常重要，特别是那些需要考虑边权重的算法，如最小生成树或最短路径算法。通过方法 either() 和 other()，可以方便地在图的上下文中使用边，而 toString() 方法则提供了边的直观表达，便于输出和调试。

myEdgeWeightedGraph

import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.StdOut;

public class myEdgeWeightedGraph
{
    private int V;
    private int E;
    private myBag<myEdge>[] adj;
    private static final String NEWLINE = System.getProperty("line.separator");

    public myEdgeWeightedGraph(int V)
    {
        this.V = V;
        this.E = E;
        adj = (myBag<myEdge>[]) new myBag[V];
        for(int v=0;v<V;v++)
            adj[v]=new myBag<myEdge>();
    }
    public myEdgeWeightedGraph(In in)
    {
        this(in.readInt());
        int E = in.readInt();
        for (int i = 0; i < E; i++)
        {
            int v = in.readInt();
            int w = in.readInt();
            double weight = in.readDouble();
            myEdge e = new myEdge(v,w,weight);
            addEdge(e);
        }
    }
    public int V() {return V;}
    public int E() {return E;}
    public void addEdge(myEdge e)
    {
        int v = e.either(),w=e.other(v);
        adj[v].add(e);
        adj[w].add(e);
        E++;
    }
    public Iterable<myEdge> adj(int v)
    {return adj[v];}
    public Iterable<myEdge> edges()
    {
        myBag<myEdge> b = new myBag<myEdge>();
        for(int v=0;v<V;v++)
            for(myEdge e: adj[v])
                if(e.other(v)<v) b.add(e);
        return b;
    }
    public String toString(){
        StringBuilder s = new StringBuilder();
        s.append(V +" vertexes "+ E + " edges " + NEWLINE);
        for(int v = 0; v<V; v++) {
            s.append(v + ": ");
            for(myEdge e:adj(v))
                s.append(e + "  ");
            s.append(NEWLINE);
        }
        return s.toString();
    }
    public static void main(String[] args)
    {
        In in = new In(args[0]);
        myEdgeWeightedGraph G = new myEdgeWeightedGraph(in);
        StdOut.print(G);
    }
}

这段代码定义了一个表示加权无向图的类 myEdgeWeightedGraph。这里的每个重要组成部分我将逐一说明：

  1. 构造函数：
    • 第一个构造函数接受一个顶点数 V，初始化图，为每个顶点创建一个用于存储边的链表。
    • 第二个构造函数通过读取一个输入源来构建图。它首先读取顶点数和边数，然后连续读取每条边的两个顶点和权重，并将这些边添加到图中。
  2. 边的添加：
    • addEdge 方法用于向图中添加一条边，同时将边添加到两个顶点的邻接链表中。
  3. 图的信息获取：
    • V() 和 E() 方法分别返回图的顶点数和边数。
    • adj(int v) 方法返回与顶点 v 相连的所有边。
    • edges() 方法返回图中的所有边，确保每条边只被列出一次。
  4. 图的字符串表示：
    • toString 方法生成并返回图的字符串描述，包括每个顶点及其相邻的边。
  5. 主函数：
    • main 方法从文件读取图数据，构建图对象，并打印图的字符串表示。

实验

代码编译

$ javac myEdge.java
$ javac myEdgeWeightedGraph.java

代码运行

$ java myEdgeWeightedGraph ..\data\tinyEWG.txt
8 vertexes 16 edges 
0: 6-0 0.58  0-2 0.26  0-4 0.38  0-7 0.16
1: 1-3 0.29  1-2 0.36  1-7 0.19  1-5 0.32
2: 6-2 0.40  2-7 0.34  1-2 0.36  0-2 0.26  2-3 0.17
3: 3-6 0.52  1-3 0.29  2-3 0.17
4: 6-4 0.93  0-4 0.38  4-7 0.37  4-5 0.35
5: 1-5 0.32  5-7 0.28  4-5 0.35
6: 6-4 0.93  6-0 0.58  3-6 0.52  6-2 0.40
7: 2-7 0.34  1-7 0.19  0-7 0.16  5-7 0.28  4-7 0.37
Greyplayground
关注
  • 17
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法刷题提高阶段-图论1
12-24
图的类型多样，包括无向图、有向图、加权图等，每种类型的图都有其特定的应用场景。 单源最短路问题是指在加权图中找到从一个特定起点（源点）到所有其他顶点的最短路径。这个问题在路由规划、网络设计、物流优化等...
加权无向图 - 最小生成树
weixin_34381687的博客
04-27 837
1. 最小生成树的定义 生成树指的是含有所有顶点的无环连通子图。注意这其中的三个限定条件： 1）包含了所有的顶点 2）不存在环 3）连通图 如上图所示。就是一个生成树。 而最小生成树指的是所有的边的权值加起来最小的生成树。最小生成树的重要应用领域太多，包括各种网络问题，例如电力分配网络，航空、铁路规划等问题。 2. 加权无向图的数据类型 //带权重的边的数据类型 p...
加权无向图
一名小白的博客
08-27 2639
加权无向图 加权无向图是一种为每条边关联一个权重值或是成本的图模型。这种图能够自然地表示许多应用。在一副航空图中，边表示航线，权值则可以表示距离或是费用。在一副电路图中，边表示导线，权值则可能表示导线的长度即成本，或是信号通过这条先所需的时间。此时我们很容易就能想到，最小成本的问题，例如，从西安飞纽约，怎样飞才能使时间成本最低或者是金钱成本最低？ 在下图中，从顶点0到顶点4有三条路径，分别为0-2-3-4,0-2-4,0-5-3-4,那我们如果要通过那条路径到达4顶点最好呢？此时就要考虑，那条路径的成本最低
加权无向图与最小生成树（Prim算法和Kruskal算法）
sc179的博客
12-07 6065
0 引入 通过加权无向图结合最小生成树相关算法，可以解决最小成本问题，并找到最小成本对应的顶点和边。 1 图的最小生成树定义及相关约定 图的生成树：图的生成树是它的一个含有其所有顶点的无环连通子图。 图的最小生成树：图的权值（所有边的权重之和）最小的生成树。 约定：最小生成树只存在于连通图中，如果图不是连通的，那么分别计算每个连通子图的最小生成树，再合并到一起形成最小生成森林。 同时为了便于理解，约定所有边的权重都不相同。（如果有权重相同的边，最小生成树可能就不唯一了） 2 最小生成树原理 2.1 性
解析加权无向图（内含代码详解）
qq_43751200的博客
04-11 3573
加权无向图 加权无向图是一种为每条边关联一个权重值或是成本的图模型。这种图能够自然地表示许多应用。 在一副航空图中，边表示航线，权值则可以表示距离或者费用。 在一副电路图中，边表示导线，权值则可能表示导线的长度即成本，或是信号通过这条边需要的时间。 此时我们很容易就能想到，最小成本的问题，例如，从西安飞纽约，怎样飞才能使时间成本最低或者是金钱成本最低？ 在下图中，从顶点0到顶点4有3条路径，分别是......
数据结构 -- 加权无向图
m0_46218511的博客
07-15 1393
一、概述 二、邻接矩阵实现（todo） 三、邻接表实现 3.1 加权无向图边 3.1.1 API设计 3.1.2 实现 3.1.3 测试 3.2 加权无向图 3.2.1 API设计 3.2.2 实现 3.2.3 测试 四、最小生成树 五、贪心算法 六、
图——加权无向图
拧发条鸟的博客
07-27 1115
所谓加权无向图，就是给连接两个顶点的边赋一个值。这在日常生活中有非常广泛的应用，例如：查找两地间用时最短的火车票，或者金钱成本最低的飞机票。 1.1 加强无向图边 构造方法 private int v; private int w; private double weight; //获取边上的权重值 public double getWeight(){ return weight; } //获取边上一个点 public int ei
算法刷题提高阶段-图论5
最新发布
12-24
最小生成树（Minimum Spanning Tree, MST）是图论中的经典问题，主要解决在一个加权无向图中找到连接所有顶点的边的集合，使得这些边的总权重最小。 首先，我们需要了解什么是图。图是由顶点（节点）和边组成的结构...
算法刷题提高阶段-图论6
12-24
最小生成树（Minimum Spanning Tree, MST）是在一个加权无向图中，找到一个边的集合，使得这些边连接了图中的所有顶点，并且这些边的总权重尽可能小。常见的最小生成树算法有Prim算法和Kruskal算法。 1. **Prim算法...
算法分析与设计-实验一 最小生成树实验报告.docx
08-21
本次实验主要关注的是如何使用Kruskal算法来找到一个加权无向图的最小生成树，并结合并查集进行优化。 一、Kruskal算法详解 Kruskal算法是一种基于贪心策略的算法，其基本思想是始终选择权值最小的边，但同时确保...
数据结构带权无向图
01-02
广度优先遍历。深度优先遍历。带权无向图。最短路径。请输入定顶点对应的数字
图论- 最短路- Floyd 算法.rar
09-16
Floyd算法，也称为Floyd-Warshall算法，是解决此类问题的一种有效方法，尤其适用于处理具有大量节点和边的加权有向图。 **Floyd-Warshall算法概述** Floyd-Warshall算法是一种动态规划策略，用于找到图中所有节点...
图论算法——加权无向图的数据结构
日积月累，天道酬勤
05-24 5567
引言 我们要在一幅加权连通无向图中找到它的最小生成树。首先要考虑的是如何表示这个无向图。 加权边的表示 package com.algorithms.graph; /** * 带权重的无向边的数据结构(不可变类) * * @author yjw * @date 2019/5/23/023 */ public final class Edge implements Comparable&...
无向图的构建，BFS、DFS遍历搜索，Prim、Kruskal最小生成树算法，Dijkstra最短路径算法
nepu_bin的博客
08-16 811
前言 在半年之前写过一篇关于无向图的构建以及相关常用算法的实现 → 图的构建以及BFS（广度优先搜索）、DFS（深度优先搜索）、普里姆最小生成树算法、并查集与kruskal算法 ，近日对这些算法进行了一个回顾，并且对其中的代码进行了全面的优化。 无向图构建 还是以之前的无向城市图为例: 上图列出了城市间的连通关系以及城市间的距离信息，下面的算法将围绕这张图进行展开。 使用临接矩阵表示无向图 在计算机中可以通过使用一些比较精妙的方式例如临界表或者临接矩阵来表示图中各节点的连接关系。笔者更加偏向于使用 临接矩
无向图的创建
qq_52785030的博客
06-21 2844
无向图的创建（C语言） 邻接链表存储结构（以正邻接链表为例） 链表示意图如下： 图邻接链表类型定义 #include "stdio.h" #include "malloc.h" #include "stdlib.h" #define MaxSize 100 typedef struct ANode { int adjvex; struct ANode *nextarc; } ArcNode;//边结点类型 typedef struct Vnoded{ int data; ArcNode *
数据结构--无向图的实现
qq_47700940的博客
10-10 302
【代码】数据结构--无向图的实现。
加权无向图的实现
机械工程跑路哥
04-17 430
一.概述 加权无向图是一种为每条边关联一个权重值或成本的图模型。这种图能够自然地表示许多应用。 在一副航空图中，边表示航线，权值则可以表示距离或是费用。在一副电路图中，边表示导线，权值则可能表示导线的长度即成本，或是信号通过这条先所需的时间。此时我们很容易就能想到，最小成本的问题。 二.实现 加权无向图中的边我们就不能简单的使用v-w两个顶点表示了，而必须要给边关联一个权重值，因此我们可以使用对象来描述一条边。 加权边类： //加权边对象 public class Edge implements Comp
算法——图之无向图
热门推荐
a60782885的博客
05-23 1万+
图的概念 图是算法中是树的拓展，树是从上向下的数据结构，结点都有一个父结点（根结点除外），从上向下排列。而图没有了父子结点的概念，图中的结点都是平等关系，结果更加复杂。 图的分类 图可以分为无向图(简单连接)，有向图(连接有方向)，加权图(连接带权值)，加权有向图(连接既有方向又有权值)。 这篇讨论无向图。 无向图的表示方法： 1.邻接矩阵 2.边的数组 3.邻接表
matlab画无向加权图
10-29
要画一个无向加权图，可以使用Matlab自带的Graph and Network Algorithms包。以下是一个简单的步骤： 1. 生成邻接矩阵A，其中A(i,j)表示第i个节点和第j个节点之间的权重。 2. 使用graph函数创建一个图像对象G，其中第一个参数是邻接矩阵A，第二个参数是节点名称。 3. 使用plot函数绘制图像，其中第一个参数是图像对象G，第二个参数是线条样式，第三个参数是线条宽度，第四个参数是标记大小。 下面是一个示例代码： ``` % 生成邻接矩阵A A = [0 1 2 0;1 0 0 3; 2 0 0 4; 0 3 4 0]; % 创建图像对象G names = {'A', 'B', 'C', 'D'}; G = graph(A, names); % 绘制图像 figure plot(G, 'LineWidth', 2, 'EdgeLabel', G.Edges.Weight) ``` 在这个示例中，我们生成了一个4个节点的邻接矩阵A，然后使用graph函数创建了一个图像对象G。最后，我们使用plot函数绘制了图像，并使用EdgeLabel参数添加了边权重标签。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值