蓝桥杯JAVA-11.图的存储方式（JAVA实现）

最新推荐文章于 2024-03-08 01:13:08 发布
最新推荐文章于 2024-03-08 01:13:08 发布
阅读量2.6k 收藏 7
点赞数 6
分类专栏： 蓝桥杯 文章标签： java 蓝桥杯 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63593632/article/details/122477408
版权

个人博客
www.tothefor.com
蓝桥杯复习知识点汇总

目录

图的存储方式这里介绍三种：邻接矩阵、临接表、链式前向星。

邻接矩阵

这是最简单的，就是用二维数组实现。例如：G[a][b] = c；表示 a 点到 b 点之间的边的权重为 c 。

示例：

package acmtest;

import java.io.*;
import java.util.*;


/**
 * @Author DragonOne
 * @Date 2021/12/11 07:13
 * @墨水记忆 www.tothefor.com
 */

public class Main {
	public static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    public static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
    public static StreamTokenizer cin = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    public static PrintWriter cout = new PrintWriter(new OutputStreamWriter(System.out));
    public static Scanner sc = new Scanner(System.in);
    
    public static int maxd = 1000+7;
    
	public static void main(String[] args) throws Exception {
		
		int[][] G = new int[maxd][maxd];
		int n = nextInt(); //n个点
		int m = nextInt(); //m条边
		while(m-->0) {
			int a = nextInt(); //a点（起点）
			int b = nextInt(); //b点（终点）
			int c = nextInt(); //边的权重
			
			//有向图
//			G[a][b] = c; //a->b
			
			// 无向图
			G[a][b] = c; //a->b
			G[b][a] = c; //b->a
			
		}
		for(int i=1;i<=n;++i) {
			for(int j=1;j<=n;++j) {
				System.out.print(G[i][j]);
			}
			System.out.println();
		}
		
		
		closeAll();
		
	}


	public static int nextInt() throws Exception{
        cin.nextToken();
        return (int) cin.nval;
    }
    public static long nextLong() throws Exception{
        cin.nextToken();
        return (long) cin.nval;
    }
    public static double nextDouble() throws Exception{
        cin.nextToken();
        return cin.nval;
    }
    public static String nextString() throws Exception{
        cin.nextToken();
        return cin.sval;
    }
    public static void closeAll() throws Exception {
        cout.close();
        in.close();
        out.close();
    }
}


//样例
4 4
1 2 7
1 3 7
2 4 7
1 3 7
    
//输出
0770
7007
7000
0700

临接表

在C++中有一个STL容器叫作Vector，Java中也有，因为是线程安全的，所以效率低。而且也已经被弃用了。

Vector实现（不推荐，知道即可）

package acmtest;

import java.io.*;
import java.util.*;


/**
 * @Author DragonOne
 * @Date 2021/12/11 07:13
 * @墨水记忆 www.tothefor.com
 */

public class Main {
	public static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    public static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
    public static StreamTokenizer cin = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    public static PrintWriter cout = new PrintWriter(new OutputStreamWriter(System.out));
    public static Scanner sc = new Scanner(System.in);
    
    public static int maxd = 1000+7;
    
	public static void main(String[] args) throws Exception {
		int n = nextInt(); //n个点
		int m = nextInt(); //m条边
		Vector<Integer>[] v = new Vector[maxd];
		for(int i=1;i<=n;++i) {
			v[i]= new Vector<>(); 
		}
		while(m-->0) {
			int a = nextInt(); //a点（起点）
			int b = nextInt(); //b点（终点）
			v[a].add(b);
			v[b].add(a);
		}
		for(int i=1;i<=n;++i) {
			int len = v[i].size();
			System.out.print(i+" ");
			for(int j=0;j<len;++j) {
				System.out.print("-> "+v[i].get(j));
			}
			System.out.println();
		}
		
		closeAll();
		
	}
	
	public static int nextInt() throws Exception{
        cin.nextToken();
        return (int) cin.nval;
    }
    public static long nextLong() throws Exception{
        cin.nextToken();
        return (long) cin.nval;
    }
    public static double nextDouble() throws Exception{
        cin.nextToken();
        return cin.nval;
    }
    public static String nextString() throws Exception{
        cin.nextToken();
        return cin.sval;
    }
    public static void closeAll() throws Exception {
        cout.close();
        in.close();
        out.close();
    }
}


//样例
4 4
1 4
1 2
2 4
2 3

//输出
1 -> 4-> 2
2 -> 1-> 4-> 3
3 -> 2
4 -> 1-> 2

ArrayList实现

package acmtest;

import java.io.*;
import java.util.*;



/**
 * @Author DragonOne
 * @Date 2021/12/11 07:13
 * @墨水记忆 www.tothefor.com
 */

public class Main {
	public static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    public static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
    public static StreamTokenizer cin = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    public static PrintWriter cout = new PrintWriter(new OutputStreamWriter(System.out));
    public static Scanner sc = new Scanner(System.in);
    
    public static int maxd = 1000+7;
    
	public static void main(String[] args) throws Exception {
		int n = nextInt(); //n个点
		int m = nextInt(); //m条边
		ArrayList[] list = new ArrayList[maxd];
		for(int i=1;i<=n;++i) {
			list[i]= new ArrayList<Integer>();
		}
		while(m-->0) {
			int a = nextInt(); //a点（起点）
			int b = nextInt(); //b点（终点）
			list[a].add(b);
			list[b].add(a);
		}
		for(int i=1;i<=n;++i) {
			int len = list[i].size();
			System.out.print(i+" ");
			for(int j=0;j<len;++j) {
				System.out.print(" -> "+list[i].get(j));
			}
			System.out.println();
		}
		
		closeAll();
		
	}
	


	public static int nextInt() throws Exception{
        cin.nextToken();
        return (int) cin.nval;
    }
    public static long nextLong() throws Exception{
        cin.nextToken();
        return (long) cin.nval;
    }
    public static double nextDouble() throws Exception{
        cin.nextToken();
        return cin.nval;
    }
    public static String nextString() throws Exception{
        cin.nextToken();
        return cin.sval;
    }
    public static void closeAll() throws Exception {
        cout.close();
        in.close();
        out.close();
    }
}

//样例
4 4
1 4
1 3
2 3
2 4

//输出
1  -> 4 -> 3
2  -> 3 -> 4
3  -> 1 -> 2
4  -> 1 -> 2

LinkedList实现

同ArrayList实现一样的道理。只是把ArrayList改成LinkedList即可。不再演示。

链式前向星

实现的效果同临接表一样（存储方式也可以理解成临接表）。只不过是通过数组实现的。

用不同的方式实现链式前向星，本质一样，只是在增加边信息（add_edge()方法）的实现方式不同。

方式一（Setter/Getter方法）

package acmtest;

import java.io.*;
import java.util.*;



/**
 * @Author DragonOne
 * @Date 2021/12/11 07:13
 * @墨水记忆 www.tothefor.com
 */

public class Main {
	public static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    public static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
    public static StreamTokenizer cin = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    public static PrintWriter cout = new PrintWriter(new OutputStreamWriter(System.out));
    public static Scanner sc = new Scanner(System.in);
    
    public static int maxd = 1000+7;
    
    public static class Edge{
    	 private int pre; // pre表示与这条边同起点的上一条边所在结点的编号
    	 private int to; // to表示这条边的终点
    	 private int w; //表示边的权重
  
		public int getPre() {
			return pre;
		}
		public void setPre(int pre) {
			this.pre = pre;
		}
		public int getTo() {
			return to;
		}
		public void setTo(int to) {
			this.to = to;
		}
		public int getW() {
			return w;
		}
		public void setW(int w) {
			this.w = w;
		}
		
    }
    
    public static int node; //边的编号
    public static int[] head = new int[maxd]; //点集 head[i]表示以i为起点的最后一条边所在结点的编号
    public static Edge[] edge = new Edge[maxd]; //存储边信息
    //初始化
    public static void init() {
    	Arrays.fill(head, -1); //-1表示没有边
    	node = 0;
    }
    //增加边信息,a点到b点的边权重为w
    public static void add_edge(int a,int b,int w) {
    	edge[node]= new Edge(); //来一个声明一个
    	edge[node].setTo(b);
    	edge[node].setW(w);
    	edge[node].setPre(head[a]);
    	head[a]=node++;
    }
    
	public static void main(String[] args) throws Exception {
		int n = nextInt(); //n个点
		int m = nextInt(); //m条边
		init();
		while(m-->0) {
			int a = nextInt(); //a点（起点）
			int b = nextInt(); //b点（终点）
			int c = nextInt(); //边的权重
			//有向图
//			add_edge(a, b, c); //a->b
			
			//无向图
			add_edge(a, b, c); //a->b
			add_edge(b, a, c); //b->a
		}
		for(int i=1;i<=n;++i) {
			System.out.print(i+" ");
			for(int j=head[i];j!=-1;j=edge[j].getPre()) { //不断寻找当前点的上一条边，没有边（为-1时）则结束
				System.out.print(" -> "+edge[j].getTo());
			}
			System.out.println();
		}
		
		closeAll();
		
	}
	

	public static int nextInt() throws Exception{
        cin.nextToken();
        return (int) cin.nval;
    }
    public static long nextLong() throws Exception{
        cin.nextToken();
        return (long) cin.nval;
    }
    public static double nextDouble() throws Exception{
        cin.nextToken();
        return cin.nval;
    }
    public static String nextString() throws Exception{
        cin.nextToken();
        return cin.sval;
    }
    public static void closeAll() throws Exception {
        cout.close();
        in.close();
        out.close();
    }
}


//样例
4 4
1 4 7
1 3 7
2 4 7
3 4 7
    
//输出
1  -> 3 -> 4
2  -> 4
3  -> 4 -> 1
4  -> 3 -> 2 -> 1

此方式还有一种实现方法，在init()方法中进行，上面的代码是在增加一条边的时候才声明一条边，现在就可以一次性把需要的边声明完。只是在声明的时候需要注意是无向图还是有向图。（边数相差两倍）

package acmtest;

import java.io.*;
import java.util.*;



/**
 * @Author DragonOne
 * @Date 2021/12/11 07:13
 * @墨水记忆 www.tothefor.com
 */

public class Main {
	public static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    public static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
    public static StreamTokenizer cin = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    public static PrintWriter cout = new PrintWriter(new OutputStreamWriter(System.out));
    public static Scanner sc = new Scanner(System.in);
    
    public static int maxd = 1000+7;
    
    public static class Edge{
    	 private int pre; // pre表示与这条边同起点的上一条边所在结点的编号
    	 private int to; // to表示这条边的终点
    	 private int w; //表示边的权重
  
		public int getPre() {
			return pre;
		}
		public void setPre(int pre) {
			this.pre = pre;
		}
		public int getTo() {
			return to;
		}
		public void setTo(int to) {
			this.to = to;
		}
		public int getW() {
			return w;
		}
		public void setW(int w) {
			this.w = w;
		}
		
    	 
    }
    public static int node; //边的编号
    public static int[] head = new int[maxd]; //点集 head[i]表示以i为起点的最后一条边所在结点的编号
    public static Edge[] edge = new Edge[maxd]; //存储边信息
    //初始化
    public static void init(int m) {
    	Arrays.fill(head, -1); //-1表示没有边
    	for(int i=0;i<=m*2;++i) { //这里是无向图，所以边数要乘2。必须要从0开始，因为边的编号是从0开始的，即node是从0开始的
    		edge[i] = new Edge();
    	}
    	node = 0;
    }
    //增加边信息,a点到b点的边权重为w
    public static void add_edge(int a,int b,int w) {
    	edge[node].setTo(b);
    	edge[node].setW(w);
    	edge[node].setPre(head[a]);
    	head[a]=node++;
    }
    
	public static void main(String[] args) throws Exception {
		int n = nextInt(); //n个点
		int m = nextInt(); //m条边
		init(m);
		while(m-->0) {
			int a = nextInt(); //a点（起点）
			int b = nextInt(); //b点（终点）
			int c = nextInt(); //边的权重
			//有向图
//			add_edge(a, b, c); //a->b
			
			//无向图
			add_edge(a, b, c); //a->b
			add_edge(b, a, c); //b->a
		}
		for(int i=1;i<=n;++i) {
			System.out.print(i+" ");
			for(int j=head[i];j!=-1;j=edge[j].getPre()) { //不断寻找当前点的上一条边，没有边（为-1时）则结束
				System.out.print(" -> "+edge[j].getTo());
			}
			System.out.println();
		}
		
		closeAll();
		
	}
	

	public static int nextInt() throws Exception{
        cin.nextToken();
        return (int) cin.nval;
    }
    public static long nextLong() throws Exception{
        cin.nextToken();
        return (long) cin.nval;
    }
    public static double nextDouble() throws Exception{
        cin.nextToken();
        return cin.nval;
    }
    public static String nextString() throws Exception{
        cin.nextToken();
        return cin.sval;
    }
    public static void closeAll() throws Exception {
        cout.close();
        in.close();
        out.close();
    }
}

方式二（构造函数）

package acmtest;

import java.io.*;
import java.util.*;



/**
 * @Author DragonOne
 * @Date 2021/12/11 07:13
 * @墨水记忆 www.tothefor.com
 */

public class Main {
	public static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    public static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
    public static StreamTokenizer cin = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    public static PrintWriter cout = new PrintWriter(new OutputStreamWriter(System.out));
    public static Scanner sc = new Scanner(System.in);
    
    public static int maxd = 1000+7;
    
    public static class Edge{
    	 private int pre; // pre表示与这条边同起点的上一条边所在结点的编号
    	 private int to; // to表示这条边的终点
    	 private int w; //表示边的权重
    	 
    	public Edge() {}
    	public Edge(int pre,int to,int w) {
			this.pre= pre;
			this.to= to;
			this.w= w;
		}
		public int getPre() {
			return pre;
		}
		public void setPre(int pre) {
			this.pre = pre;
		}
		public int getTo() {
			return to;
		}
		public void setTo(int to) {
			this.to = to;
		}
		public int getW() {
			return w;
		}
		public void setW(int w) {
			this.w = w;
		}
		
    	 
    }
    public static int node; //边的编号
    public static int[] head = new int[maxd]; //点集 head[i]表示以i为起点的最后一条边所在结点的编号
    public static Edge[] edge = new Edge[maxd]; //存储边信息
    //初始化
    public static void init() {
    	Arrays.fill(head, -1); //-1表示没有边
    	node = 0;
    }
    //增加边信息,a点到b点的边权重为w
    public static void add_edge(int a,int b,int w) {
    	edge[node]= new Edge(head[a],b,w); 
    	head[a]=node++;
    }
    
	public static void main(String[] args) throws Exception {
		int n = nextInt(); //n个点
		int m = nextInt(); //m条边
		init();
		while(m-->0) {
			int a = nextInt(); //a点（起点）
			int b = nextInt(); //b点（终点）
			int c = nextInt(); //边的权重
			//有向图
//			add_edge(a, b, c); //a->b
			
			//无向图
			add_edge(a, b, c); //a->b
			add_edge(b, a, c); //b->a
		}
		for(int i=1;i<=n;++i) {
			System.out.print(i+" ");
			for(int j=head[i];j!=-1;j=edge[j].getPre()) { //不断寻找当前点的上一条边，没有边（为-1时）则结束
				System.out.print(" -> "+edge[j].getTo());
			}
			System.out.println();
		}
		
		closeAll();
		
	}
	

	public static int nextInt() throws Exception{
        cin.nextToken();
        return (int) cin.nval;
    }
    public static long nextLong() throws Exception{
        cin.nextToken();
        return (long) cin.nval;
    }
    public static double nextDouble() throws Exception{
        cin.nextToken();
        return cin.nval;
    }
    public static String nextString() throws Exception{
        cin.nextToken();
        return cin.sval;
    }
    public static void closeAll() throws Exception {
        cout.close();
        in.close();
        out.close();
    }
}

//样例
4 4
1 4 7
1 3 7
2 4 7
3 4 7
    
//输出
1  -> 3 -> 4
2  -> 4
3  -> 4 -> 1
4  -> 3 -> 2 -> 1
墨水记忆
关注
专栏目录
Java版 图的三种存储方式
Sherlock的博客
08-06 747
邻接矩阵 用二维矩阵进行存储的方式，用于边数较多的稠密图。 //w[a][b] = c 表示 从a到b有权重为c的边 int [][]w = new int[N][N]; //加边操作 void add(int a, int b, int c) { w[a][b] = c; } 链式前向星（本质是邻接表，数组模拟链表） 适用于稀疏图，边数较少时，这种存储在图论中十分常见 // h[i] 存储某个结点所对的边 所在链表的头结点 //e[i] 存储某一条边指向的结点（边的终点） //ne[i].
Java实现图的存储和创建，大牛深入讲解
m0_60666570的博客
08-31 208
存储结构选用邻接表。 当一个图为稀疏图时，使用邻接矩阵法显然要浪费大量的存储空间，而图的邻接表法结合了顺序存储和链式存储方法，大大减少了这种不必要的浪费。 当然，即使我们所处理的图不是稀疏图，邻接表法也是能够胜任的。 []( )图、顶点以及边的代码定义 public class graph_t { //邻接表实现的带权无向图 private ArrayList<VNode> vertices; //邻接表 private int vexNum; //顶点数目
Java实现图的存储和创建
闻风听雨的博客
07-26 1327
带权无向图 存储结构 存储结构选用邻接表。 当一个图为稀疏图时，使用邻接矩阵法显然要浪费大量的存储空间，而图的邻接表法结合了顺序存储和链式存储方法，大大减少了这种不必要的浪费。 当然，即使我们所处理的图不是稀疏图，邻接表法也是能够胜任的。 图、顶点以及边的代码定义 public class graph_t { //邻接表实现的带权无向图 private ArrayList<VNode> vertices; //邻接表 private int vexNum; //顶点
【算法】图的存储和遍历（Java）
每天更新大数据面经和技术
04-24 1167
  今天学习图的存储和遍历。 1.图的存储 图的存储一般采用领接矩阵和邻接表。这里讲解邻接表。简单来说，邻接表就是每个顶点定义一个列表，记录该顶点的所有出边。这里可以用 ArrayList 来存储每个节点的出边。 // 邻接表 List<List<Integer>> edges = new ArrayList<>(); // 每个节点 new 一个 List 存放出边 for (int i = 0; i < n; i++) { edges.add(new A
用Java集合实现有向图的领接表存储
Codewarning
05-20 343
1.ArrayList+LinkedList import java.util.ArrayList; import java.util.LinkedList; import java.util.Scanner; public class Main { static final int MAX=10; public static void main(String[] args) { Scanner cin=new Scanner(System.in); Arr
蓝桥杯java模拟试题.pdf
07-14
蓝桥杯 Java 模拟试题 本试卷包含两种题型：“代码填空”与“程序设计”。填空题要求参赛选手在弄清给定代码工作原理的基础上填写缺失的部分，使得程序逻辑正确、完整。所填写的代码不多于一条语句（即不能出现分号...
西风蓝桥杯 国赛warehouse-6-master.zip
最新发布
06-02
"西风蓝桥杯"是一项知名的编程竞赛，旨在提升参赛者的软件开发和算法设计能力。"warehouse-6-master.zip"这个文件名暗示了它可能是一个关于仓库管理系统的项目，可能是比赛的一个任务或案例。"master"通常指的是版本...
蓝桥杯-基于Java的蓝桥杯练习系统的题解.zip
02-10
【标题】"蓝桥杯-基于Java的蓝桥杯练习系统的题解.zip" 提供的是一份关于如何使用Java语言解决蓝桥杯竞赛中的问题的综合指南。蓝桥杯是一项全国性的编程竞赛，旨在提升大学生的算法设计和编程能力。这份资源可能是...
蓝桥杯ADV101-121.pdf
11-23
【蓝桥杯ADV101】断案问题 这是一个逻辑推理问题，主要涉及逻辑运算和条件判断。题目中给出了四个嫌疑人甲、乙、丙、丁的陈述，且只有一个人是小偷。每个人的话要么全部真实，要么全部虚假。我们需要根据他们的陈述...
蓝桥杯Java试题汇总-共48页.docx
06-22
【蓝桥杯Java试题汇总】涉及的Java编程知识点主要包括数据处理、条件判断、循环结构、字符串操作以及递归算法。 1. **核桃的数量问题**： 这是一道关于求解最大公约数（Greatest Common Divisor, GCD）的问题。...
有向图存储和遍历-java实现.zip
07-15
有向图存储和遍历-java实现，纯java代码，一共两个文件，有mian方法，导入新建java工程即可用。包含有向图的存储和遍历。
图的邻接表存储及遍历（JAVA）
04-12
NULL 博文链接：https://128kj.iteye.com/blog/1694918
java实现图的邻接表存储结构的两种方式及实例应用详解
08-25
主要介绍了java实现图的邻接表存储结构的两种方式及实例应用详解,邻接表构建图是必须需要一个Graph对象，也就是图对象！该对象包含属性有：顶点数、边数以及图的顶点集合,需要的朋友可以参考下
图 邻接表 java_java实现图的邻接表存储结构的两种方式及实例应用详解
weixin_31734677的博客
02-12 529
前言本篇来谈一谈图的邻接表实现的两种方式，首先我们明确一点“学会图的邻接表实现的关键点在于“：你所建立的图的邻接表的对象是什么！首先我们看一下《算法导论》中关于图的邻接表的定义：图G=(V,E)的邻接表表示有一个包含 |V| 个列表的数组Adj所组成，其中每个列表对应于V中的一个顶点，对于每一个u∈V，邻接表Adj[u]包含所有满足条件(u，v)∈E的顶点v，亦即，Adj[u]包含图G中所有和顶点...
java中图的两种存储方式
杨煜冬煜杨的博客
08-09 5259
大家知道，图这种数据结构在java中有邻接表与邻接矩阵这两种存储方式，前者编程相对复杂但是效率较高，后者编程相对简单但是效率较低，我们利用java可以很容易的实现这两种数据结构。代码如下 邻接矩阵的存储方式： public class MGraph { private int[][] edges;//邻接矩阵 private int numOfEdges;//边的数目 pr
蓝桥杯- 图形显示（java）
好好学java
04-01 338
算法训练 图形显示 时间限制：1.0s 内存限制：512.0MB 问题描述 　　编写一个程序，首先输入一个整数，例如5，然后在屏幕上显示如下的图形（5表示行数）： 　　* * * * * 　　* * *...
图的存储方式的JAVA实现
12-03 3244
1.概述在日常生活中,对象与对象之间的关系可以用示意图来表示。图在各个领域的应用广泛,在计算机的应用领域如开关理论，逻辑设计，人工智能，形式语言，操作系统以及编译程序及信息检索内，图都起着重要的作用。下面看一下图的几个概念:有向图:有向图是连线带有箭头的,具有方向性。在有向图中,属于边E的集合,未必有属于E。无向图:无向图是不带有箭头的,无方向性。在无向图中,(Vi,Vj)属于边E的集合,必须有属于边E.、邻结点:在无向图中,(Vi,Vj)属于E,则称Vi与Vj为端点,并称它们互为邻结点。在有向图中,属于E
图的存储结构与实现总结-java版
许诗宇的博客
05-21 4026
目录 图的存储结构 邻接矩阵 邻接表 两者区别 图的java实现 顶点 边 图 测试 图的存储结构 图的存储结构主要分两种，一种是邻接矩阵，一种是邻接表。 邻接矩阵 图的邻接矩阵存储方式是用两个数组来表示图。一个一维数组存储图中顶点信息，一个二维数组（邻接矩阵）存储图中的边或弧的信息。 设图G有n个顶点，则邻接矩阵是一个n*n的方阵，定义为： 看一个实例，下图...
图的两种存储结构 邻接矩阵和邻接表 java实现
mlfc0422的博客
03-08 932
邻接矩阵是一种表示图的数据结构，通过二维数组来表示图中的顶点和边的关系。在邻接矩阵中，行和列分别代表图中的顶点，而矩阵中的元素表示顶点之间是否有边，以及边的权重（在带权图中）。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值