图论01-【无权无向】-图的基本表示-邻接矩阵/邻接表

news2024/11/16 15:40:40

文章目录

  • 1. 代码仓库
  • 2. 图的基本表示的比较
  • 3. 邻接矩阵：Array和TreeSet
    • 3.1 图示
    • 3.2 Array主要代码解析
    • 3.3 测试输出
    • 3.4 使用TreeSet的代码
  • 4. 邻接表：LinkedList
    • 4.1 图示
    • 4.2 LinkedList主要代码解析
    • 4.3 测试输出
  • 5. 完整代码
    • 5.1 邻接表 - Array
    • 5.2 邻接表-TreeSet
    • 5.3 邻接矩阵-LinkedList
    • 5.4 输入文件

1. 代码仓库

https://github.com/Chufeng-Jiang/Graph-Theory/tree/main/src/Chapt01_Adjacency

2. 图的基本表示的比较

在这里插入图片描述

3. 邻接矩阵：Array和TreeSet

3.1 图示

在这里插入图片描述

3.2 Array主要代码解析

代码有删减

public AdjMatrix(String filename){
    File file = new File(filename);
    try(Scanner scanner = new Scanner(file)){       
        V = scanner.nextInt(); //读取第一行第一个数,代表图中的顶点数
        
        //构造邻接矩阵
        adj = new int[V][V]; 
        E = scanner.nextInt(); //读取第一行第二个数，代表图中边的数量
        
        // E是边的数量，在g.txt中表示为第二行开始的E行
        for (int i = 0; i < E; i++) {
            int a = scanner.nextInt(); //读取边的一个顶点
            int b = scanner.nextInt(); //读取边的另一个顶点

            adj[a][b] = 1; //存在边则设置为1
            adj[b][a] = 1;
        }
    }
}

在这里插入图片描述

3.3 测试输出

在这里插入图片描述

3.4 使用TreeSet的代码

代码有删减
只需要改动一行

adj = new TreeSet[V]; //构造邻接表, V行，V个LinkedList

在这里插入图片描述

4. 邻接表：LinkedList

4.1 图示

在这里插入图片描述

4.2 LinkedList主要代码解析

代码有删减

public class AdjList {
    private int V;
    private int E;
    private LinkedList<Integer>[] adj;

    public AdjList(String filename){
        File file = new File(filename);
        try(Scanner scanner = new Scanner(file)){
            V = scanner.nextInt();
            
            /*构造邻接表, V行，V个LinkedList*/
            adj = new LinkedList[V]; 
            for (int i = 0; i < V; i++) {
               adj[i] = new LinkedList<Integer>();
            }

            E = scanner.nextInt(); //读取第一行第二个数

            // E是边的数量，在g.txt中表示为第二行开始的E行
            for (int i = 0; i < E; i++) {
                int a = scanner.nextInt(); //读取边的一个顶点
                int b = scanner.nextInt(); //读取边的另一个顶点
                adj[a].add(b);
                adj[b].add(a);
            }
        }
    }

在这里插入图片描述

4.3 测试输出

在这里插入图片描述

5. 完整代码

5.1 邻接表 - Array

package Chapt01_Adjacency;

import java.io.File;
import java.io.IOException;
import java.util.LinkedList;
import java.util.Scanner;


public class AdjList {
    private int V;
    private int E;
    private LinkedList<Integer>[] adj;

    public AdjList(String filename){
        File file = new File(filename);
        try(Scanner scanner = new Scanner(file)){
            V = scanner.nextInt();
            if(V < 0) throw new IllegalArgumentException("V must be non-negative");

            adj = new LinkedList[V]; //构造邻接表, V行，V个LinkedList
            for (int i = 0; i < V; i++) {
               adj[i] = new LinkedList<Integer>();
            }

            E = scanner.nextInt(); //读取第一行第二个数
            if(E < 0) throw new IllegalArgumentException("E must be non-negative");

            // E是边的数量，在g.txt中表示为第二行开始的E行
            for (int i = 0; i < E; i++) {
                int a = scanner.nextInt(); //读取边的一个顶点
                validateVertex(a);
                int b = scanner.nextInt(); //读取边的另一个顶点
                validateVertex(b);

                if(a == b) throw new IllegalArgumentException("Self Loop is Detected"); //判断是够存在自环边
                if(adj[a].contains(b)) throw new IllegalArgumentException("Parallel Edges are Detected"); //判断是够存在平行l边

                adj[a].add(b);
                adj[b].add(a);
            }
        }
        catch (IOException e){
            e.printStackTrace();
        }
    }

    private void validateVertex(int v){
        if(v < 0 || v >= V)
            throw new IllegalArgumentException("vertex" + v + "is invalid");
    }

    public int V(){
        return V;
    }

    public int E(){
        return E;
    }

    public boolean hasEdge(int v, int w){
        validateVertex(v);
        validateVertex(w);
        return adj[v].contains(w);
    }

    public LinkedList<Integer> adj(int v){
        validateVertex(v);
        return adj[v];
    }

    public int degree(int v){
        return adj(v).size();
    }

    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("V = %d, E = %d\n", V, E));

        for (int i = 0; i < V; i++) {
            sb.append(String.format("%d:",i));
            for (int w: adj[i]) {
                sb.append(String.format("%d ",w));
            }
            sb.append('\n');
        }
        return sb.toString();
    }

    public static void main(String[] args){
        AdjList adjList = new AdjList("g1.txt"); //新建邻接矩阵，并从文件内容初始化
        System.out.println(adjList);
    }
}

5.2 邻接表-TreeSet

package Chapt01_Adjacency;

import java.io.File;
import java.io.IOException;
import java.util.Scanner;
import java.util.TreeSet;

public class AdjSet {
    private int V;
    private int E;
    private TreeSet<Integer>[] adj;

    public AdjSet(String filename){
        File file = new File(filename);
        try(Scanner scanner = new Scanner(file)){
            V = scanner.nextInt();
            if(V < 0) throw new IllegalArgumentException("V must be non-negative");
            adj = new TreeSet[V]; //构造邻接表, V行，V个LinkedList
            for (int i = 0; i < V; i++) {
               adj[i] = new TreeSet<Integer>();
            }

            E = scanner.nextInt(); //读取第一行第二个数
            if(E < 0) throw new IllegalArgumentException("E must be non-negative");

            // E是边的数量，在g.txt中表示为第二行开始的E行
            for (int i = 0; i < E; i++) {
                int a = scanner.nextInt(); //读取边的一个顶点
                validateVertex(a);
                int b = scanner.nextInt(); //读取边的另一个顶点
                validateVertex(b);

                if(a == b) throw new IllegalArgumentException("Self Loop is Detected"); //判断是够存在自环边
                if(adj[a].contains(b)) throw new IllegalArgumentException("Parallel Edges are Detected"); //判断是够存在平行l边

                adj[a].add(b);
                adj[b].add(a);
            }
        }
        catch (IOException e){
            e.printStackTrace();
        }
    }

    private void validateVertex(int v){
        if(v < 0 || v >= V)
            throw new IllegalArgumentException("vertex" + v + "is invalid");
    }

    public int V(){
        return V;
    }

    public int E(){
        return E;
    }

    public boolean hasEdge(int v, int w){
        validateVertex(v);
        validateVertex(w);
        return adj[v].contains(w);
    }

    public Iterable<Integer> adj(int v){ // 可以是TreeSet，但是数组、链表、红黑树都是实现了Iterable的接口，因此可以统一写成这样
        validateVertex(v);
        return adj[v];
    }

    public int degree(int v){
        validateVertex(v);
        return adj[v].size(); // Iterable没有size()方法
    }

    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("V = %d, E = %d\n", V, E));

        for (int i = 0; i < V; i++) {
            sb.append(String.format("%d:",i));
            for (int w: adj[i]) {
                sb.append(String.format("%d ",w));
            }
            sb.append('\n');
        }
        return sb.toString();
    }

    public static void main(String[] args){
        AdjSet adjSet = new AdjSet("g1.txt"); //新建邻接矩阵，并从文件内容初始化
        System.out.println(adjSet);
    }
}

5.3 邻接矩阵-LinkedList

package Chapt01_Adjacency;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

public class AdjMatrix {
    private int V;
    private int E;
    private int[][] adj;

    // 构造函数，从文件内容初始化邻接矩阵
    public AdjMatrix(String filename){
        File file = new File(filename);
        try(Scanner scanner = new Scanner(file)){
            V = scanner.nextInt(); //读取第一行第一个数,代表图中的顶点数
            if(V < 0) throw new IllegalArgumentException("V must be non-negative");

            adj = new int[V][V]; //构造邻接矩阵

            E = scanner.nextInt(); //读取第一行第二个数，代表图中边的数量
            if(E < 0) throw new IllegalArgumentException("E must be non-negative");

            // E是边的数量，在g.txt中表示为第二行开始的E行
            for (int i = 0; i < E; i++) {
                int a = scanner.nextInt(); //读取边的一个顶点
                validateVertex(a);
                int b = scanner.nextInt(); //读取边的另一个顶点
                validateVertex(b);

                if(a == b) throw new IllegalArgumentException("Self Loop is Detected"); //判断是够存在自环边
                if(adj[a][b] == 1) throw new IllegalArgumentException("Parallel Edges are Detected"); //判断是否存在平行l边

                adj[a][b] = 1; //存在边则设置为1
                adj[b][a] = 1;
            }
        }
        catch (IOException e){
            e.printStackTrace();
        }
    }

    private void validateVertex(int v){
        if(v < 0 || v >= V)
            throw new IllegalArgumentException("vertex" + v + "is invalid");
    }

    public int V(){
        return V;
    }

    public int E(){
        return E;
    }

    public boolean hasEdge(int v, int w){
        validateVertex(v);
        validateVertex(w);
        return adj[v][w] == 1;
    }

    public ArrayList<Integer> adj(int v){
        validateVertex(v);
        ArrayList<Integer> res = new ArrayList<>();
        for (int i = 0; i < V; i++) {
           if(adj[v][i] == 1) res.add(i);
        }
        return res;
    }

    public int degree(int v){
        return adj(v).size(); //adj(v)是上方的adj方法，size()是ArrayList的接口
    }

    // 用于在控制台打印该临接矩阵
    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("V = %d, E = %d\n", V, E)); //打印顶点数和边的数量

        for (int i = 0; i < V; i++) { //行
            for (int j = 0; j < V; j++) { //列
                sb.append(String.format("%d",adj[i][j])); //读取矩阵的值
            }
            sb.append('\n'); //行尾换行
        }
        return sb.toString(); //返回该邻接矩阵
    }

    public static void main(String[] args){
        AdjMatrix adjMatrix = new AdjMatrix("g1.txt"); //新建邻接矩阵，并从文件内容初始化
        System.out.println(adjMatrix);

    }
}

5.4 输入文件

7 9
0 1
0 3
1 2
1 6
2 3
2 5
3 4
4 5
5 6

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1116177.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Hadoop3教程（二十七）：（生产调优篇）HDFS读写压测

Hadoop3教程（二十七）：（生产调优篇）HDFS读写压测

文章目录 &#xff08;146&#xff09;HDFS压测环境准备&#xff08;147&#xff09;HDFS读写压测写压测读压测 参考文献 &#xff08;146&#xff09;HDFS压测环境准备 对开发人员来讲&#xff0c;压测这个技能很重要。 假设你刚搭建好一个集群&#xff0c;就可以直接投入生…
阅读更多...
屏幕录像推荐：Apeaksoft Screen Recorder 中文 for mac

屏幕录像推荐：Apeaksoft Screen Recorder 中文 for mac

Apeaksoft Screen Recorder 是一款功能强大的屏幕录制软件&#xff0c;它允许用户在 Windows 和 Mac 系统上捕捉和录制屏幕活动。无论是记录游戏过程、创建教学视频、制作演示文稿还是捕捉在线流媒体内容&#xff0c;该软件都提供了丰富的功能和工具。 以下是 Apeaksoft Scree…
阅读更多...
【LeetCode每日一题合集】2023.10.9-2023.10.15（贪心⭐位运算的应用：只出现一次的数字）

【LeetCode每日一题合集】2023.10.9-2023.10.15（贪心⭐位运算的应用：只出现一次的数字）

文章目录 2578. 最小和分割&#xff08;贪心&#xff09;2731. 移动机器人&#xff08;脑筋急转弯排序统计&#xff09;2512. 奖励最顶尖的 K 名学生&#xff08;哈希表排序&#xff09;&#xff08;练习Java语法&#xff09;代码风格1代码风格2 2562. 找出数组的串联值&#x…
阅读更多...
基于Linux的驱动开发：内核模块传参、内核到处符号表、字符设备驱动

基于Linux的驱动开发：内核模块传参、内核到处符号表、字符设备驱动

内核模块传参 内核模块&#xff1a; int a , b; 安装内核模块时&#xff1a;insmod demo.ko a 100 b 10; 1.内核模块传参的意义 在安装内核模块时给内核模块中的变量进行数值传递&#xff0c;这样可以让我们的内核模块向上兼容更为复杂的应用程序&#xff0c;向下适配多种硬件…
阅读更多...
网络协议--ARP：地址解析协议

网络协议--ARP：地址解析协议

4.1 引言 本章我们要讨论的问题是只对TCP/IP协议簇有意义的IP地址。数据链路如以太网或令牌环网都有自己的寻址机制&#xff08;常常为48 bit地址&#xff09;&#xff0c;这是使用数据链路的任何网络层都必须遵从的。一个网络如以太网可以同时被不同的网络层使用。例如&#…
阅读更多...
解剖—单链表相关OJ练习题

解剖—单链表相关OJ练习题

目录 一、移除链表元素 二、找出链表的中间节点 三、合并两个有序链表 四、反转链表 五、求链表中倒数第k个结点 六、链表分割 七、链表的回文结构 八、判断链表是否相交 九、判断链表中是否有环(一) 十、 判断链表中是否有环(二) 注&#xff1a;第六题和第七题牛…
阅读更多...
三网话费余额查询的API系统 基于thinkphp6.0框架

三网话费余额查询的API系统 基于thinkphp6.0框架

本套系统是用thinkphp6.0框架开发的&#xff0c;PHP需大于8.2&#xff0c;系统支持用户中心在线查询和通过API接口对接发起查询&#xff0c;用户余额充值是对接usdt接口&#xff0c;源码全开源&#xff0c;支持懂技术的人二次开发~搭建教程1、源码上传后&#xff0c;吧运行目录…
阅读更多...
异常数据检测 | Python基于Hampel的离群点检测

异常数据检测 | Python基于Hampel的离群点检测

文章目录 文章概述模型描述源码分享文章概述 在时间序列数据分析领域，识别和处理异常点是至关重要的任务。异常点或离群点是明显偏离预期模式的数据点，可能表明存在错误、欺诈或有价值的见解。 应对这一挑战的一种有效技术是汉普尔过滤器（Hampel Filter）。 模型描述 汉…
阅读更多...
Manacher学习笔记

Manacher学习笔记

Manacher 算法&#xff0c;俗称马拉车算法&#xff0c;是一种解决最长回文子串问题的算法。 在 Ybt 的哈希章节中出现了这个&#xff1a; 数据范围 1 0 6 10^6 106&#xff0c;数据相对于马拉车模板较弱。 对于一个普通的字符串&#xff0c;我们要想求出它的回文子串需要考虑它…
阅读更多...
聊天机器人语料在开发中的重要性

聊天机器人语料在开发中的重要性

语料在聊天机器人的开发中起着至关重要的作用&#xff0c;使其能够有效理解和回应用户的查询。语料是聊天机器人的训练数据&#xff0c;通过分析和学习这个语料&#xff0c;聊天机器人可以提高对用户意图的准确理解&#xff0c;并生成恰当的回应。 | 一、聊天机器人语料好在哪&…
阅读更多...
Unity 单例-接口模式

Unity 单例-接口模式

单例-接口模式 使用接口方式实现的单例可以继承其它类&#xff0c;更加方便 using System.Collections; using System.Collections.Generic; using UniRx; using UniRx.Triggers; using UnityEngine; namespace ZYF {public interface ISingleton<TMono> where TMono : M…
阅读更多...
Redis-Sentinel高可用架构学习

Redis-Sentinel高可用架构学习

Redis-Sentinel高可用架构 Redis主从复制过程&#xff1a; 主从同步原理 Redis Sentinel&#xff08;哨兵&#xff09;高可用集群方案&#xff1a;Redis-Sentinel是Redis官方推荐的高可用性(HA)解决方案。 当用Redis做Master-slave的高可用方案时&#xff0c;假如master宕机了…
阅读更多...
微信小程序之后台首页交互

微信小程序之后台首页交互

目录 一.与后台数据进行交互&request封装 后台准备 测试结果 ​编辑 前端 测试结果 二.wxs的介绍以及入门 测试结果 一.与后台数据进行交互&request封装 后台准备 pom.xml文件编写 <?xml version"1.0" encoding"UTF-8"?> <proj…
阅读更多...
【JavaEE】常见的锁策略 -- 多线程篇(4)

【JavaEE】常见的锁策略 -- 多线程篇(4)

文章目录 乐观锁 vs 悲观锁读写锁重量级锁 vs 轻量级锁自旋锁&#xff08;Spin Lock&#xff09;公平锁 vs 非公平锁可重入锁 vs 不可重入锁 乐观锁 vs 悲观锁 悲观锁: 总是假设最坏的情况&#xff0c;每次去拿数据的时候都认为别人会修改&#xff0c;所以每次在拿数据的时候都…
阅读更多...
全连接网络参数Xavier初始化

全连接网络参数Xavier初始化

1.梯度消失 考虑下图的神经网络&#xff0c;在使用梯度下降法迭代更新W_ki和W_ij时&#xff0c;它们的梯度方向间有什么关系&#xff1f; 它们的梯度关系如下&#xff1a; 从上述两个式子我们大致可以看出&#xff0c;损失函数L关于第h层参数的梯度由两部分组成&#xff1a;…
阅读更多...
sql server2014如何添加多个实例 | 以及如何删除多个实例中的单个实例

sql server2014如何添加多个实例 | 以及如何删除多个实例中的单个实例

标题sql server2014如何添加多个实例 前提&#xff08;已安装sql server2014 且已有默认实例MSSQLSERVER&#xff09; 添加新的实例 其实就是根据安装步骤再安装一次&#xff08;区别在过程中说明&#xff09; 双击安装 选择“全新独立安装或添加现有功能” 然后下一步下一…
阅读更多...
微信小程序开发之后台数据交互及wxs应用

微信小程序开发之后台数据交互及wxs应用

目录 一、后端准备 1. 应用配置 2. 数据源配置 二、数据库 1. 创建 2. 数据表 3. 数据测试 三、前端 1. 请求方法整合 2. 数据请求 3. WXS的使用 4. 样式美化 5. 页面 一、后端准备 通过SpringMVC及mybatis的技术学习&#xff0c;还有前后端分离的技术应用&…
阅读更多...
Linux程序地址

Linux程序地址

目录 一、定义 二、问题引出 三、虚拟地址和物理地址 &#xff08;一&#xff09;问题解释 &#xff08;二&#xff09;什么是进程地址空间 &#xff08;三&#xff09;为什么要有进程地址空间 一、定义 #include <stdio.h> #include <stdlib.h>//geten…
阅读更多...
运维监控Zabbix部署

运维监控Zabbix部署

目录 运维监控Zabbix部署 1. 简介 2. 安装 ​编辑 2.1 安装前准备 - Mysql 2.2 安装Zabbix Server 和 Zabbix Agent 2.2.1 安装Zabbix yum库 2.2.2 安装Zabbix Server、前端、Agent 2.2.3 初始化Mysql数据库 2.2.4 为Zabbix Server配置数据库 2.2.5 配置Zab…
阅读更多...
【目标检测】Co-DETR：ATSS+Faster RCNN+DETR协作的先进检测器（ICCV 2023）

【目标检测】Co-DETR：ATSS+Faster RCNN+DETR协作的先进检测器（ICCV 2023）

论文&#xff1a;DETRs with Collaborative Hybrid Assignments Training 代码**&#xff1a;https://github.com/Sense-X/Co-DETR 文章目录 摘要一、简介二、本文方法2.1.概述2.2.协同混合分配训练2.3. 定制的正 Query 生成2.4. Co-DETR为何有效1、丰富编码器的监督2、通过减少…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023