Experiment 8. Graph

已于 2022-11-27 10:52:41 修改
阅读量165 收藏
点赞数 2
文章标签： java 算法 开发语言
于 2022-11-26 17:59:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62835729/article/details/128054850
版权

test 2 Dijkstra

核心代码

主要是利用了个优先队列简化了一些，目的就只是实现功能，不考虑空间，时间了。

package Experiment8;

import java.util.Comparator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;


public class test2 {
    public static void main(String[] args) {
        //-------------------------Dijkstra算法

        Graph graph = new Graph();     //构建图

        //创建各个节点
        Vertex a = new Vertex("A");graph.addVertex(a);
        Vertex b = new Vertex("B");graph.addVertex(b);
        Vertex c = new Vertex("C");graph.addVertex(c);
        Vertex d = new Vertex("D");graph.addVertex(d);
        Vertex e = new Vertex("E");graph.addVertex(e);
        Vertex f = new Vertex("F");graph.addVertex(f);

        //创建节点联系
        a.addOut(d,30);a.addOut(c,5);a.addIn(b,2);

        b.addIn(c,15);b.addOut(a,2);b.addOut(e,8);

        c.addIn(a,5);c.addOut(b,15);c.addOut(f,7);

        d.addIn(a,30);d.addIn(e,4);d.addIn(f,10);

        e.addIn(b,8);e.addIn(f,18);e.addOut(d,4);

        f.addIn(c,7);f.addOut(e,18);f.addOut(d,10);



        //给每个顶点距离初始化为无穷大
        for(Vertex v: graph.vertexLinkedList){
            v.dis =  Integer.MAX_VALUE;
            v.known = false;
        }

        Queue<Vertex> que = new PriorityQueue<>((v1,v2)->(v1.dis-v2.dis)); //lambda表达式
                                                 //采用优先队列对加入的点进行升序排序，队头即为距离最小的顶点
        a.dis = 0;

        for(Vertex v1: graph.vertexLinkedList)
            que.add(v1);                      //将所有顶点加入至优先队列

        while(!que.isEmpty()){            //注意，这边为空就表明全部都访问过了，有些省略不易理解
            Vertex tmp = que.poll();      //弹出最小的
            tmp.known = true;             //标记为已经访问过
            for(Edge e1:tmp.out){
                if(!e1.v1.known&&tmp.dis+e1.weight<e1.v1.dis){
                    e1.v1.dis = tmp.dis+e1.weight;
                    que.remove(e1.v1);                          //采用优先队列的方式值改变后应当重新出队再入队，才能更新顺序
                    que.add(e1.v1);
                    e1.v1.path = tmp;
                }
            }
        }

        for(Vertex v:graph.vertexLinkedList){
            System.out.print("Destination: "+v.val+"      ");
            graph.printPath(v);
            System.out.println();
        }
    }
}

顶点类：

package Experiment8;

import java.util.LinkedList;

class Vertex{                  //顶点
    String val;                //数值
    LinkedList<Edge> out = new LinkedList<>();         //出度
    LinkedList<Edge> in = new LinkedList<>();          //入度
    int dis;
    boolean known;
    Vertex path;

    public  Vertex(){}
    public  Vertex(String val){
        this.val = val;
    }
    public void addIn(Vertex v){
        Edge e = new Edge(v);
        in.add(e);
    }
    public void addOut(Vertex v){
        Edge e = new Edge(v);
        out.add(e);
    }
    public void addIn(Vertex v,int w){
        Edge e = new Edge(w,v);
        in.add(e);
    }
    public void addOut(Vertex v,int w){
        Edge e = new Edge(w,v);
        out.add(e);
    }

}

边类：

package Experiment8;

class Edge{
    int weight;
    Vertex v1;
    Edge(){}
    Edge(int w,Vertex v1){
        this.weight = w;
        this.v1 = v1;
    }
    Edge(Vertex v1){
        this.v1 = v1;
    }
}

图类：

package Experiment8;

import java.util.LinkedList;

class Graph{
    Graph(){
        vertexLinkedList = new LinkedList<>();
    }
     LinkedList<Vertex> vertexLinkedList;      //顶点集

    public void addVertex(Vertex v){       //加入顶点
        vertexLinkedList.add(v);
    }
    public void clear(){
        vertexLinkedList.clear();
    }

    public  boolean AllVisited(){
        return vertexLinkedList.size()==checkVisited();
    }

    int checkVisited(){
        int cnt = 0;
        for (Vertex v:vertexLinkedList){
            if (v.known==true) cnt++;
        }
        return cnt;
    }
    public void printPath(Vertex v){
        if(v.path!=null){
            printPath(v.path);
            System.out.print("->");
        }
        System.out.print(v.val+"(dis:"+v.dis+")");
    }
}

test3 和 test2 代码上基本一样，就改动了 dis 的计算

核心代码

package Experiment8;

import java.util.PriorityQueue;
import java.util.Queue;

public class test3 {
    public static void main(String[] args) {
        //-------------------------Prime算法

        Graph graph = new Graph();     //构建图

        //创建各个节点
        Vertex a = new Vertex("A");graph.addVertex(a);
        Vertex b = new Vertex("B");graph.addVertex(b);
        Vertex c = new Vertex("C");graph.addVertex(c);
        Vertex d = new Vertex("D");graph.addVertex(d);
        Vertex e = new Vertex("E");graph.addVertex(e);
        Vertex f = new Vertex("F");graph.addVertex(f);

        //创建节点联系
        a.addIn(d,30);a.addIn(c,5);a.addIn(b,2);

        b.addIn(c,15);b.addIn(a,2);b.addIn(e,8);

        c.addIn(a,5);c.addIn(b,15);c.addIn(f,7);

        d.addIn(a,30);d.addIn(e,4);d.addIn(f,10);

        e.addIn(b,8);e.addIn(f,18);e.addIn(d,4);

        f.addIn(c,7);f.addIn(e,18);f.addIn(d,10);

        //给每个顶点距离初始化为无穷大
        for(Vertex v: graph.vertexLinkedList){
            v.dis =  Integer.MAX_VALUE;
            v.known = false;
        }

        Queue<Vertex> que = new PriorityQueue<>((v1,v2)->(v1.dis-v2.dis)); //lambda表达式
        //采用优先队列对加入的点进行升序排序，队头即为距离最小的顶点
        a.dis = 0;

        for(Vertex v1: graph.vertexLinkedList)
            que.add(v1);                      //将所有顶点加入至优先队列

        while(!que.isEmpty()){            //注意，这边为空就表明全部都访问过了，有些省略不易理解
            Vertex tmp = que.poll();      //弹出最小的
            tmp.known = true;             //标记为已经访问过
            for(Edge e1:tmp.in){
                if(!e1.v1.known&&e1.weight<e1.v1.dis){          //就在这个范围内改了下
                    e1.v1.dis = e1.weight;
                    que.remove(e1.v1);                          //采用优先队列的方式值改变后应当重新出队再入队，才能更新顺序
                    que.add(e1.v1);
                    e1.v1.path = tmp;
                }
            }
        }

        //输出最小生成树

    }
}

test 4

核心代码：

package Experiment8;

import java.util.*;

public class test4 {
    public static void main(String[] args) {
        //-------------------------Kruskal算法

        Graph graph = new Graph();     //构建图

        //创建各个节点
        Vertex a = new Vertex("A");graph.addVertex(a);
        Vertex b = new Vertex("B");graph.addVertex(b);
        Vertex c = new Vertex("C");graph.addVertex(c);
        Vertex d = new Vertex("D");graph.addVertex(d);
        Vertex e = new Vertex("E");graph.addVertex(e);
        Vertex f = new Vertex("F");graph.addVertex(f);

        //创建节点联系（无向边）
        Edge tmp = new Edge(2,a,b);graph.addEdge(tmp);
        tmp = new Edge(30,a,d);graph.addEdge(tmp);
        tmp = new Edge(5,a,c);graph.addEdge(tmp);
        tmp = new Edge(15,b,c);graph.addEdge(tmp);
        tmp = new Edge(8,b,e);graph.addEdge(tmp);
        tmp = new Edge(7,c,f);graph.addEdge(tmp);
        tmp = new Edge(4,e,d);graph.addEdge(tmp);
        tmp = new Edge(10,f,d);graph.addEdge(tmp);
        tmp = new Edge(18,f,e);graph.addEdge(tmp);


        Queue<Edge> que = new PriorityQueue<>((v1, v2)->(v1.weight-v2.weight)); //lambda表达式
                                                     //采用优先队列对加入的边进行升序排序，队头即为权重最小的边
        for(Edge e1: graph.edgeArrayList){
            que.add(e1);
        }

        DisjSets sets = new DisjSets(graph);

        List<Edge> mst = new ArrayList<>();

        while (mst.size()!=graph.vertexLinkedList.size()-1){
            Edge e2 = que.poll();
            Set<Vertex> s1 = sets.find(e2.v1);
            Set<Vertex> s2 = sets.find(e2.v2);

            if(s1!=s2){
                mst.add(e2);
                sets.union(s1,s2);
            }
        }

        for(Edge e2:mst){
            System.out.println(e2.v1.val+"--"+e2.v2.val);
        }


    }
}

class DisjSets{
    int size;
    ArrayList<Set<Vertex>> sets;
    Set<Vertex> set;
    DisjSets(Graph graph){
        sets = new ArrayList<>();

        for(Vertex v: graph.vertexLinkedList){            //将全部的顶点作为一个集合初始化
            set = new HashSet<>();
            set.add(v);
            sets.add(set);
        }
    }

    void union(Set<Vertex> s1,Set<Vertex> s2){
        s2.addAll(s1);
        sets.remove(s1);
    }

    Set<Vertex> find(Vertex v){
        for(Set<Vertex> s:sets){
            if(s.contains(v)) return s;
        }
        return null;
    }
}

在边类里也更新了下

package Experiment8;

class Edge{
    int weight;
    Vertex v1;
    Vertex v2;
    Edge(){}
    Edge(int w,Vertex v1){
        this.weight = w;
        this.v1 = v1;
    }
    Edge(Vertex v1){
        this.v1 = v1;
    }
    Edge(int w,Vertex v1,Vertex v2){
        this.weight = w;
        this.v1 = v1;
        this.v2 = v2;
    }
}

test 5 和test 6是在图类中添加了dfs 和 bfs

核心代码：

图类

package Experiment8;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;

class Graph{
    Graph(){
        vertexLinkedList = new LinkedList<>();
        edgeArrayList = new ArrayList<>();
    }
     LinkedList<Vertex> vertexLinkedList;      //顶点集
    ArrayList<Edge> edgeArrayList;             //无向边的边集合

    public void addVertex(Vertex v){       //加入顶点
        vertexLinkedList.add(v);
    }
    public void clear(){
        vertexLinkedList.clear();
    }

    public  boolean AllVisited(){
        return vertexLinkedList.size()==checkVisited();
    }

    int checkVisited(){
        int cnt = 0;
        for (Vertex v:vertexLinkedList){
            if (v.known==true) cnt++;
        }
        return cnt;
    }
    public void printPath(Vertex v){
        if(v.path!=null){
            printPath(v.path);
            System.out.print("->");
        }
        System.out.print(v.val+"(dis:"+v.dis+")");
    }
    public void addEdge(Edge e){edgeArrayList.add(e);}
    void dfs(Vertex v){
        v.known = true;
        System.out.print(v.val+"->");
        for(Edge e1:v.in){
            if(!e1.v1.known)
                dfs(e1.v1);
        }

    }
    Queue<Vertex> que = new LinkedList<>();
    void bfs(Vertex v){
        que.add(v);
        v.known = true;

        while (!que.isEmpty()) {
            int cnt = 0;
            Vertex tmp = que.poll();
            for (Edge e1 : tmp.in) {
                if (!e1.v1.known) {
                    System.out.println(tmp.val + "->" +e1.v1.val);
                    e1.v1.known = true;
                    que.add(e1.v1);
                    cnt++;
                }
            }
            if(cnt>0) System.out.println("-------start:"+tmp.val+"---------");
        }
    }
}

test5 主程序

package Experiment8;

public class test5 {

    public static void main(String[] args) {
        //-------------------------dfs算法

        Graph graph = new Graph();     //构建图

        //创建各个节点
        Vertex a = new Vertex("A");graph.addVertex(a);
        Vertex b = new Vertex("B");graph.addVertex(b);
        Vertex c = new Vertex("C");graph.addVertex(c);
        Vertex d = new Vertex("D");graph.addVertex(d);
        Vertex e = new Vertex("E");graph.addVertex(e);
        Vertex f = new Vertex("F");graph.addVertex(f);

        //创建节点联系（无向边）
        a.addIn(b,2);a.addIn(d,30);a.addIn(c,5);

        b.addIn(e,8);b.addIn(c,15);b.addIn(a,2);

        c.addIn(f,7);c.addIn(b,15);c.addIn(a,5);

        d.addIn(e,4);d.addIn(a,30);d.addIn(f,10);

        e.addIn(b,8);e.addIn(d,4);e.addIn(f,18);

        f.addIn(e,18);f.addIn(c,7);f.addIn(d,10);

        graph.dfs(a);
    }
}

test 6 主程序

package Experiment8;

public class test6 {
    public static void main(String[] args) {
        //-------------------------dfs算法

        Graph graph = new Graph();     //构建图

        //创建各个节点
        Vertex a = new Vertex("A");graph.addVertex(a);
        Vertex b = new Vertex("B");graph.addVertex(b);
        Vertex c = new Vertex("C");graph.addVertex(c);
        Vertex d = new Vertex("D");graph.addVertex(d);
        Vertex e = new Vertex("E");graph.addVertex(e);
        Vertex f = new Vertex("F");graph.addVertex(f);

        //创建节点联系（无向边）
        a.addIn(b,2);a.addIn(d,30);a.addIn(c,5);

        b.addIn(e,8);b.addIn(c,15);b.addIn(a,2);

        c.addIn(f,7);c.addIn(b,15);c.addIn(a,5);

        d.addIn(e,4);d.addIn(a,30);d.addIn(f,10);

        e.addIn(b,8);e.addIn(d,4);e.addIn(f,18);

        f.addIn(e,18);f.addIn(c,7);f.addIn(d,10);

        graph.bfs(a);
    }
}

weie99
关注
ann_experiment
02-09
2. **算法类型**: 常见的ANN算法有基于树的数据结构（如kd树、球树、B树等）、Hashing技术（如Locality Sensitive Hashing, LSH）、向量量化方法（如Product Quantization, PQ）以及Graph-based方法（如M-Tree, P-...
图的基本数据结构
微雨入兰泽
03-16 298
代码来自《数据结构(C++版)》机械工程出版社 /** Graph()创建一个空图 addVertex(vert): 将顶点vert加入图 addEdge(fromVert, toVert):添加有向边 addEdge(fromVert, toVert, weight):添加带权的有向边 getVertex(vKey):查找名称为vKey的顶点 getVertices()：返回顶点列表 in:按照vert in graph的语句形式，返回顶点是否存在图中 */ /** 模型:.
数据结构_图(Graph)
It's just a matter of time.
12-06 2262
图(Graph)是为了模拟解决一类现实中的问题的而设计的数据结构，个人觉得相对于二叉搜索树，它并没有什么算法操作的的优势，只是它可以很好的模拟显示中的图问题。图的表示可以用邻接矩阵和邻接表来表示，本文就使用邻接矩阵的方法实现了一下简单的无向图。
graphlab试用笔记
非●梵高
09-04 1844
1.编译问题 mpi1.6会有hang up 的情况。 使用 1.4.5 https://bbs.archlinux.org/viewtopic.php?id=145518 gcc 必须大于 4.2  2.sample运行问题 bool line_parser #include #include using namespace std; struct web_page
Java数据结构----图--最短路径解法Dijkstra算法和Floyd算法
热门推荐
ChangWen的博客
02-24 2万+
最短路径—Dijkstra算法和Floyd算法 1、Dijkstra算法 1.1、定义概览 Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法是很有代表性的最短路径算法，在很多专业课程中都作为基本内容有详细的介绍，如数据结构，图论，运筹学等等。注意该算法要求图中不
java数据结构之图及其深度优先搜索与最小生成树
java__liyong的博客
12-20 501
定义： 图 (graph) 是由一些点 (vertex) 和这些点之间的连线 (edge) 所组成的；其中，点通常被成为 "顶点(vertex)"，而点与点之间的连线则被成为 "边或弧"(edege)。通常记为，G=(V,E)。 DFS(Depth-first-search) 深度优先遍历 形象的说, 就像搜索文件夹, 从第一个开始文件夹开始搜索到底, 然后再搜索第二个到底, 然后第三个…...
graph-attribution:用于评估图神经网络归因的代码库
05-08
import graph_attribution as gatt task_type = 'benzene' block_type = 'gcn' exp , task , methods = gatt . experiments . get_experiment_setup ( task_type , block_type ) hp = gatt . hparams . get_hparams
学术论文写作 | (3) Experiment写作套路
12-14
描述图表中的实验结果，可以这么说： ...The most interesting aspect of this graph is … In Fig.10 there is a clear trend of decreasing …(在图10中，有明显的下降趋势。) What is interesting a
EventTriplesExtraction:An experiment and demo-level tool for text information extraction (event-triples extraction), which can be a route to the event chain and topic graph, 基于依存句法与语义角色标注的事件三元组抽取，可用于文本理解如文档主题链，事件线等应用
05-28
EventTriplesExtraction  EventTriplesExtraction based on dependency parser and semantic role labeling, 基于依存句法与语义角色标注的事件三元组抽取  文本表示一直是个重要问题，如何以清晰，简介的方式对一...
LabWork4.0图像分析软件.pdf
09-30
此外，用户还可以通过"1D-Gels"下的"Show Graph…"显示泳道轮廓图，以便观察光密度值或亮度值的变化，以及调整计算光密度值的面积。 背景校正是定量分析中的重要环节。LabWork 4.0提供了多种背景校正方法，如从轮廓...
Java用邻接矩阵实现广度优先
FlowLeaf
08-27 1857
定义节点类：//一个节点 class Vertex{ char label; boolean wasVisited; public Vertex(char label){ this.label = label; wasVisited = false; } }图：class Graph{ private final int MA
jGraphX 绘图总结，增加大量节点和边的效率问题。
yuxiaohui78的专栏
04-21 4459
参考jGraphx手册: http://jgraph.github.io/mxgraph/docs/manual_javavis.html#1.6.1 JGraphX的核心是JGraphX Model 几乎所有的修改动作，都需要调用model的方法： 下面是核心方法： mxGraphModel.beginUpdate() - starts a new transact
图解Janusgraph系列-分布式id生成策略分析
Tech Station
12-14 2407
通过JanusGraph源码带你领略分布式id生成策略的魅力~
解决error: undefined reference to g2o::OptimizableGraph::addVertex问题
mameng4的博客
09-04 4626
**解决error: undefined reference to `g2o::OptimizableGraph::addVertex问题**
JavaScript实现图结构
Ben_Simons
08-15 816
JavaScript实现图结构 一、图论 1.1.图的简介 什么是图？ 图结构是一种与树结构有些相似的数据结构； 图论是数学的一个分支，并且，在数学中，树是图的一种； 图论以图为研究对象，研究顶点和边组成的图形的数学理论和方法； 主要的研究目的为：事物之间的联系，顶点代表事物，边代表两个事物间的关系； 图的特点： 一组顶点：通常用V（Vertex）表示顶点的集合； 一组边：通常用E（Edge）表示边的集合； 边是顶点和顶点之间的连线； 边可以是有向的，也可以是无向的。比如A-...
通过Gremlin语言构建关系图并进行图分析
Jermy的专栏
09-04 6661
背景 Gremlin是Apache TinkerPop框架下实现的图遍历语言，支持OLTP与OLAP，是目前图数据库领域主流的查询语言，可类比关系型数据库之于SQL语言。 HugeGraph是国内的一款开源图数据库，完全支持Gremlin语言。本文将讲述如何在HugeGraph图数据库上通过Gremlin来构建一张图，并进行一些基本的图分析。该图描述了TinkerPop框架、Gremlin语言...
JanusGraph批量导入数据代码总结
不积跬步，无以至千里；不积小流，无以成江海！
06-03 9101
这里写自定义目录标题说明1. Json导入到本地TinkerGraph1.1 配置1.2 样例Json1.3 代码1.4 文件校验2. CSV导入到本地TinkerGraph2.1 配置2.2 样例CSV2.3 代码2.4 文件校验3. Json导入到分布式存储(berkeleyje-es)3.1 配置3.2 样例Json3.3 代码3.4 验证 说明 本文中的代码基于janusgraph 0.3...
使用 hugegraph-studio 插入电影数据并查询
苏黎世黄昏
03-20 4133
1. 插入数据 schema = graph.schema(); schema.propertyKey("name").asText().create(); schema.propertyKey("born").asInt().create(); schema.propertyKey("title").asText().create(); schema.propertyKey("released...
Graph-图可视化
zhangkai1992的专栏
10-11 3851
1 Jung2介绍 随着Graph图相关的应用，基于一种可视化工具进行数据分析是一种十分必要的工具，将极大便利的加快分析。随着大数据的发展，图神经网络，基于图的团伙发现算法，聚集算法等越来越多的应用到业务之中，仅仅从数据角度来看图的结果比较晦涩难懂，本文介绍一种java的可视化图Graph的工具-jung2，对于英文较好的同学，这里有一篇英文文档专门介绍Jung的使用方式，可以一读。http://www.grotto-networking.com/JUNG/JUNG2-Tutorial.pdf 2 步骤 .
how can i use 'plotly.graph_objs' to visualize volume datas?
最新发布
05-17
You can use the `plotly.graph_objs` module to create a variety of visualizations, including those that display volume data. Here's an example of how to use this module to create a 3D visualization of volume data: ```python import plotly.graph_objs as go import numpy as np # Generate some fake volume data x, y, z = np.mgrid[-10:10:20j, -10:10:20j, -10:10:20j] values = x * x * 0.5 + y * y + z * z * 2 # Create the 3D volume trace trace = go.Volume( x=x.flatten(), y=y.flatten(), z=z.flatten(), value=values.flatten(), isomin=10, isomax=50, opacity=0.1, # set opacity for the volume surface_count=17, # number of isosurface values colorscale='Viridis', # set colorscale ) # Create the layout layout = go.Layout( title='3D Volume Visualization', margin=dict(l=0, r=0, b=0, t=40), scene=dict( xaxis=dict(title='X'), yaxis=dict(title='Y'), zaxis=dict(title='Z') ) ) # Create the figure fig = go.Figure(data=[trace], layout=layout) # Show the figure fig.show() ``` In this example, we start by generating some fake volume data using the `numpy` module. We then create a `go.Volume` trace object, which takes in the x, y, and z coordinates of the data, as well as the values at each point. We also set a few other parameters, such as the opacity and colorscale. Next, we create a layout object, which sets the title and axis labels for the visualization. Finally, we create a `go.Figure` object, which combines the trace and layout objects, and show the figure using the `show()` method. Note that the `plotly` library provides many other types of traces and customization options, so you can experiment with different settings to create the visualization that best suits your needs.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值