玩转图论算法（1）图的基本表示【Java实现】

「爱情、让人受尽委屈。」 2023-07-03 06:05 15阅读 0赞

**2-1 图的分类**

图是一个用线 或 边连接在一起的顶点的集合，可以说，图是有限 顶点V 和 边E 的有序对。顶点（Vertex），边（Edge）

图a中的边没有方向，称为**无向图**。图b中边存在方向称为**有向图**。

1.1(a) 所示的图可以表示为  *G* 1 ( *V* ,  *E* ) 。其中顶点集合  *V* ( *G* 1 ) = \{ 1, 2, 3, 4, 5, 6 \} ，集合

中的元素为顶点（用序号代表，在其他图中，顶点集合中的元素也可以是其他标识顶点的符号，

如字母  *A* 、 *B* 、 *C*  等）；

边的集合为： *E* ( *G* 1 ) = \{ (1, 2), (1, 3), (2, 3), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (4, 5) \}

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70][]

图  1.1(b) 所示的图可以表示为  *G* 2 ( *V* ,  *E* ) ，其中顶点集合  *V* ( *G* 2 ) = \{ 1, 2, 3, 4, 5, 6, 7 \} ，集合中的元素也为顶点的序号；

边的集合为：

*E* ( *G* 2 ) = \{ <1, 2>, <2, 3>, <2, 5>, <2, 6>, <3, 5>, <4, 3>, <5, 2>, <5, 4>, <6, 7> \} 。

在上述边的集合中，每个元素 < *u* ,  *v* > 为一对顶点构成的有序对（用尖括号括起来），

表示从点 *u*  到顶点  *v*  的 **有向边** （ *directed Edge* ）

**权值** （ *weight* ）：某些图的边具有与它相关的数，称为权值。

下列图示分别表示：**无向有权图，有向有权图**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 1][]

上图a中：所示的无向网可表示为 *G*1(*V*, *E*)，其中顶点集合 *V*(*G*1) = \{ 1, 2, 3, 4, 5, 6, 7 \}；

边的集合为：

*E* ( *G* 1 ) = \{ (1, 2, 28), (1, 6, 10), (2, 3, 16), (2, 7, 14), (3, 4, 12), (4, 5, 22), (4, 7, 18), (5, 6, 25), (5, 7, 24) \}。

在边的集合中，每个元素的第  3  个分量表示该边的权值。

所以依据图的有无方向和权值可以分为4类：

**1.无向无权图**

**2.有向无权图**

**3.无向有权图**

**4.有向有权图**

###    2-2 图的基本概念 ###

**顶点的度（degree）**：对于无向图来说，一个顶点的度就是这个顶点的相邻的边的数量。如第一张图a中点1的度就是 2 。

**简单图**：没有自环边，没有平行边

**子图：**例如，图 1.8(a)、(b)所示的无向图都是图 1.1(a)所示的无向图 *G*1的子图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 2][]

**联通图和非联通图：**

在无向图中，若从顶点  *u*  到  *v*  有路径，则称顶点  *u*  和  *v*是**连通的**（ *connected* ）。

如果无向图中任意一对顶点都是连通的，则称此图是 **连通图** （ *connected*  *graph* ）；

相反，如果一个无向图不是连通图，则称为 **非连通图** （ *disconnected graph* ）。

如果一个无向图不是连通的，则其极大连通子图称为 **连通分量** （ *connected component* ）

![aHR0cDovL2RhdGEuYmlhbmNoZW5nLm5ldC91cGxvYWRzL2FsbGltZy8xOTAxMDUvMi0xWjEwNTA5MzM0MTFHLmdpZg][]

**树是一种无环图**，任意结点都可以看做是根节点。**联通的无环图是树**。

**生成树** （ *Spanning Tree* ）：一个无向连通图 的生成树是它的包含所有顶点的极小连通子图，这里所谓的极小就是边的数目极小。

**如果图中有 *n* 个顶点，则生成树有 *n*\-1**  **条边**。一个无向连通图可能有多个生成树。

图1.1(a)  所示的无向图  *G* 1 的一个生成树如图  1.9(a) 所示。为了更形象地表示这个生成树，

在图 1.9 中，图(b) 把它画成了以顶点  1  为根结点的树，图 (c) 把它画成了以顶点  3  为根结点的树。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 3][]

###    2-3 图的基本表示：邻接矩阵 ###

在邻接矩阵存储方法中，除了一个记录各个顶点信息的 **顶点数组** 外，还有一个表示各个顶点

之间关系的矩阵，称为 **邻接矩阵** （ *adjacency matrix* ）。两顶点相邻则为1， 不相邻则为 0

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 5][]

其中 V = 7 表示顶点的数量， E = 9 表示边的数量

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 6][]

练习的是简单图，不包含自环边和平行边

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 必须是个不为负数的数值");
    			adj = new int[V][V];  // 创建二维矩阵
    			
    			E = scanner.nextInt();
    			if (V < 0) throw new IllegalArgumentException("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("不允许存在自环边");
    				if (adj[a][b] == 1) throw new IllegalArgumentException("不允许存在平行边");
    				adj[a][b] = 1;
    				adj[b][a] = 1;
    			}
    			
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    	
    	private void validateVertex(int v) {
    		if (v < 0 || v > V) {
    			throw new IllegalArgumentException("输入的数值" + v +"不合法");
    		}
    	}
    	
    	// 获取指定结点相邻的结点
    	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();
    	}
    	
    	public int V() {
    		return V;
    	}
    	
    	public int E() {
    		return E;
    	}
    	
    	public boolean hasEdge(int x, int y) {  // 依据两个顶点判断边是否存在
    		validateVertex(x);
    		validateVertex(y);
    		return adj[x][y] == 1;
    	}
    	
    	public String toString() {
    		
    		StringBuilder stringBuilder = new StringBuilder();
    		stringBuilder.append(String.format("V = %d, E = %d \n", V, E)); 
    		// 打印出矩阵
    		for (int i =0; i< V; i++) {
    			for (int j = 0; j < V; j++) {
    				stringBuilder.append(String.format("%d ", adj[i][j]));
    			}
    			stringBuilder.append("\n");
    		}
    		
    		return stringBuilder.toString();
    		
    	}
    
    	public static void main(String[] args) {
    		AdjMatrix adjMatrix = new AdjMatrix("g.txt");
    		System.out.println(adjMatrix);
    //		V = 7, E = 9 
    //		0 1 0 1 0 0 0 
    //		1 0 1 0 0 0 1 
    //		0 1 0 1 0 1 0 
    //		1 0 1 0 1 0 0 
    //		0 0 0 1 0 1 0 
    //		0 0 1 0 1 0 1 
    //		0 1 0 0 0 1 0 
    		System.out.println(adjMatrix.adj(2).toString());
    		System.out.println(adjMatrix.degree(2));
    
    	}
    
    }

###  ###

###    2-4 图的基本表示：邻接表 ###

谓 **邻接表** （ *adjacency list* ），就是把从同一个顶点发出的边链接在同一个称为 **边链表** 的单链表中。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 7][]

###    2-6 邻接表的实现 ###

###  ###

**空间复杂度为：** O(V+E) ，V表示结点，E 表示边

**时间复杂度为：**

1. 建立图形：O(E \* V)

2. 查看两个结点是否相邻：O（degree(V)） 该节点的度。

3. 求一个点的相邻结点: O（degree(V)） 该节点的度

邻接表的代码实现;

package all_graphy_alog;
    
    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 必须是个不为负数的数值");
    			adj = new LinkedList[V];  // 创建链表
    			for (int i = 0; i < V; i++) {
    				adj[i] = new LinkedList<>();  // 对于每个顶点创建一个链表
    			}
    			
    			E = scanner.nextInt();
    			if (V < 0) throw new IllegalArgumentException("E 必须是个不为负数的数值");
    			
    			for (int i = 0; i< V; i++) {  // 遍历边的数量就可以了
    				int a = scanner.nextInt();
    				validateVertex(a);
    				int b = scanner.nextInt();
    				validateVertex(b);
    				// 判断是否是自环边
    				if (a == b) throw new IllegalArgumentException("不允许存在自环边");
                    // 此时，链表contains的时间复杂度为 O（N）的
    				if (adj[a].contains(b)) throw new IllegalArgumentException("不允许存在平行边");
    				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("输入的数值" + v +"不合法");
    		}
    	}
    	
    	// 获取指定结点相邻的结点
    	public LinkedList<Integer> adj(int v){
    		validateVertex(v);
    		return adj[v];
    	}
    	
    	// 获取指定结点的度，即相邻的结点的数量
    	public int degree(int v) {
    		return adj(v).size();
    	}
    	
    	public int V() {
    		return V;
    	}
    	
    	public int E() {
    		return E;
    	}
    	
    	public boolean hasEdge(int x, int y) {  // 依据两个顶点判断边是否存在
    		validateVertex(x);
    		validateVertex(y);
    		return adj[x].contains(y);
    	}
    	
    	public String toString() {
    		
    		StringBuilder stringBuilder = new StringBuilder();
    		stringBuilder.append(String.format("V = %d, E = %d \n", V, E)); 
    		// 打印出矩阵
    		for (int v =0; v< V; v++) {
    			stringBuilder.append(String.format("%d ： ", v));
    			for (int w: adj[v]) {  // 遍历链表
    				stringBuilder.append(String.format(" %d ", w));
    			}
    			stringBuilder.append("\n");
    		}
    		
    		return stringBuilder.toString();
    		
    	}
    
    	public static void main(String[] args) {
    		AdjList adjMatrix = new AdjList("g.txt");
    		System.out.println(adjMatrix);
    		System.out.println(adjMatrix.adj(2).toString());
    		System.out.println(adjMatrix.degree(2));
    		
    //		V = 7, E = 9 
    //		0 ：  1  3 
    //		1 ：  0  2  6 
    //		2 ：  1  3  5 
    //		3 ：  0  2  4 
    //		4 ：  3 
    //		5 ：  2 
    //		6 ：  1 
    //
    //		[1, 3, 5]
    //		3		
    	}
    
    }

对于查看两个结点是否相邻：O（degree(V)） 该节点的度。改进的话，使用哈希表为O（1），较快；红黑树为 O(logV)，能保证数据的有序，红黑树更能节省空间。

**使用红黑树进行改进：只需要给几个代码就可以**

package all_graphy_alog;
    
    import java.io.File;
    import java.io.IOException;
    import java.util.TreeSet;
    import java.util.Scanner;
    
    //只是处理简单的图,使用红黑树
    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 必须是个不为负数的数值");
    			adj = new TreeSet[V];  // 创建链表
    			for (int i = 0; i < V; i++) {
    				adj[i] = new TreeSet<>();  // 对于每个顶点创建一个链表
    			}
    			
    			E = scanner.nextInt();
    			if (V < 0) throw new IllegalArgumentException("E 必须是个不为负数的数值");
    			
    			for (int i = 0; i< V; i++) {  // 遍历边的数量就可以了
    				int a = scanner.nextInt();
    				validateVertex(a);
    				int b = scanner.nextInt();
    				validateVertex(b);
    				// 判断是否是自环边
    				if (a == b) throw new IllegalArgumentException("不允许存在自环边");
    				// 此时红黑树的遍历复杂度为 O(logN)
    				if (adj[a].contains(b)) throw new IllegalArgumentException("不允许存在平行边");
    				adj[a].add(b); // 复杂度为 O（N）
    				adj[b].add(a);  // 将数据保存在链表中
    			}
    			
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    	
    	private void validateVertex(int v) {
    		if (v < 0 || v > V) {
    			throw new IllegalArgumentException("输入的数值" + v +"不合法");
    		}
    	}
    	
    	// 获取指定结点相邻的结点
    	public Iterable<Integer> adj(int v){
    		validateVertex(v);
    		return adj[v];
    	}
    	
    	// 获取指定结点的度，即相邻的结点的数量
    	public int degree(int v) {
    		validateVertex(v);
    		return adj[v].size();
    	}
    	
    	public int V() {
    		return V;
    	}
    	
    	public int E() {
    		return E;
    	}
    	
    	public boolean hasEdge(int x, int y) {  // 依据两个顶点判断边是否存在
    		validateVertex(x);
    		validateVertex(y);
    		return adj[x].contains(y);
    	}
    	
    	public String toString() {
    		
    		StringBuilder stringBuilder = new StringBuilder();
    		stringBuilder.append(String.format("V = %d, E = %d \n", V, E)); 
    		// 打印出矩阵
    		for (int v =0; v< V; v++) {
    			stringBuilder.append(String.format("%d ： ", v));
    			for (int w: adj[v]) {  // 遍历链表
    				stringBuilder.append(String.format(" %d ", w));
    			}
    			stringBuilder.append("\n");
    		}
    		
    		return stringBuilder.toString();
    		
    	}
    
    	public static void main(String[] args) {
    		AdjSet adjMatrix = new AdjSet("g.txt");
    		System.out.println(adjMatrix);
    		System.out.println(adjMatrix.adj(2).toString());
    		System.out.println(adjMatrix.degree(2));
    		
    //		V = 7, E = 9 
    //		0 ：  1  3 
    //		1 ：  0  2  6 
    //		2 ：  1  3  5 
    //		3 ：  0  2  4 
    //		4 ：  3 
    //		5 ：  2 
    //		6 ：  1 
    //
    //		[1, 3, 5]
    //		3		
    	}
    
    }

**图的基本的表示方法：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 8][]

--------------------

### 项目推荐： ###

**[2000多G的计算机各行业电子资源分享（持续更新）][2000_G]**

**[2020年微信小程序全栈项目之喵喵交友【附课件和源码】][2020]**

**[Spring Boot开发小而美的个人博客【附课件和源码】][Spring Boot]**

**[Java微服务实战296集大型视频-谷粒商城【附代码和课件】][Java_296_-]**

**[Java开发微服务畅购商城实战【全357集大项目】-附代码和课件][Java_357_-]**

**[最全最详细数据结构与算法视频-【附课件和源码】][-]**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70_pic_center]

。。。。。。。。。。。。。end。。。。。。。。。。。。。

--------------------

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200414111416968.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200414112222120.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200414114745487.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1,size_16,color_FFFFFF,t_70
[aHR0cDovL2RhdGEuYmlhbmNoZW5nLm5ldC91cGxvYWRzL2FsbGltZy8xOTAxMDUvMi0xWjEwNTA5MzM0MTFHLmdpZg]: https://imgconvert.csdnimg.cn/aHR0cDovL2RhdGEuYmlhbmNoZW5nLm5ldC91cGxvYWRzL2FsbGltZy8xOTAxMDUvMi0xWjEwNTA5MzM0MTFHLmdpZg
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200414140736930.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200414144355213.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200414144421188.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200414145322921.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200424095505663.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200424104931262.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1,size_16,color_FFFFFF,t_70
[2000_G]: https://mp.weixin.qq.com/s/sP4JgGWkCzpgwKr9sAV2_Q
[2020]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487704&idx=1&sn=5f4b2127c4d49fd07ae072a0721424a2&chksm=e8036fc2df74e6d489c4aa9b06f917ef7cee6027f13e150fca53cf79d5d188d4ccc1af49e098&scene=21#wechat_redirect
[Spring Boot]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487798&idx=2&sn=ac0293b996521b872a9dba5fbb3e65e6&chksm=e8036e2cdf74e73aba104a9a994a5b2e31483e8dcbe0f1d9936f6d5173b887e1560f59d2819c&scene=21#wechat_redirect
[Java_296_-]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487674&idx=1&sn=7aff0bdf2bb727303f3d3618995aef21&chksm=e8036fa0df74e6b6d872c7e6ece179c524ed463a4a6b74c96875475c9a3d5ddb903427dd993b&scene=21#wechat_redirect
[Java_357_-]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247486376&idx=1&sn=d1fef270c463ea8ac663f6fbfedd70a0&chksm=e80374b2df74fda4d3bafba878a106a19e18c5fcda266008f4f37975847a21bc612ffcd5ff39&scene=21#wechat_redirect
[-]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487750&idx=1&sn=747bccbb5f5ea6b58915198de40da777&chksm=e8036e1cdf74e70ae97a5e8e265b49d7236d904d291203309159d07ba1724033062c0e370843&scene=21#wechat_redirect
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20210105230611623.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1,size_16,color_FFFFFF,t_70#pic_center