图数据结构详解-优快云博客

本文链接：https://blog.youkuaiyun.com/zero_ko/article/details/107433405

本文深入探讨了图数据结构的基本概念，包括无向图、有向图和带权图，以及图的表示方式如邻接矩阵和邻接表。详细讲解了图的深度优先遍历和广度优先遍历算法，通过实例演示了两种遍历方式的实现过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

图基本介绍

为什么要有图

线性表局限于一个直接前驱和一个直接后继的关系
树也只能有一个直接前驱也就是父节点
当我们需要表示多对多的关系时，这里我们就用到了图。

图的举例说明

图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。结点也可以称为顶点。如图:

在这里插入图片描述

图的常用概念

顶点(vertex)
边(edge)
路径
无向图
有向图
带权图

图的表示方式

图的表示方式有两种:二维数组表示(邻接矩阵) ;链表表示(邻接表)。

邻接矩阵

邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点的图而言，矩阵是的row和col表示的是…n个点。
在这里插入图片描述

邻接表

1)邻接矩阵需要为每个顶点都分配n个边的空间，其实有很多边都是不存在，会造成空间的–定损失.
2)邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间浪费，邻接表由数组+链表组成
3)举例说明
在这里插入图片描述

图的深度优先遍历介绍

图遍历介绍

所谓图的遍历，即是对结点的访问。一个图有那么多个结点，如何遍历这些结点，需要特定策略，一般有两种访问策略: (1)深度优先遍历(2)广度优先遍历

深度优先遍历基本思想

图的深度优先搜索(Depth First Search)。

深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点，可以这样理解:每次都在访问完当前结点后首先访问当前结点的第一个邻接结点。
可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。
显然，深度优先搜索是一个递归的过程

深度优先遍历算法步骤

访问初始结点v，并标记结点v为已访问。
查找结点v的第一个邻接结点W。
若w存在，则继续执行4，如果w不存在，则回到第1步，将从v的下一个结点继续。
若w未被访问，对w进行深度优先遍历递归(即把w当做另一个v，然后进行步骤123) 。
查找结点v 的w邻接结点的下一一个邻接结点，转到步骤3。
分析图（dfs：A B C D E）

在这里插入图片描述

存储顶点String使用 ArrayList
保存矩阵int[][] edges

深度遍历代码实现

package com.xhl.Graph;

import java.util.ArrayList;

public class Graph {

	private ArrayList<String> vertexList;//存储定点集合
	private int[][] edges;//存储邻接矩阵
	private int numOfEdges;//边的数目
	private boolean[] isVisited;//记录节点是否被访问
	
	public static void main(String[] args) {
		int n = 5;
		Graph graph = new Graph(n);
		String vertexs[] = {"1","2","3","4","5"};
		graph.intsertVertex(vertexs);
		
		graph.insertEdge(0, 1);
		graph.insertEdge(2, 1);
		graph.insertEdge(3, 1);
		graph.insertEdge(2, 4);
		
		graph.dfs();
	}
	private void intsertVertex(String[] vertexs){
		for(String vertex:vertexs) {
			vertexList.add(vertex);
		}
	}
	//构造器
	public Graph(int n) {
		edges = new int[n][n];
		vertexList = new ArrayList(n);
		numOfEdges = 0;
	}
	
	//深度遍历
	private void dfs(boolean[] isVisited,int i) {
		System.out.printf(vertexList.get(i)+"\t");
		isVisited[i]=true;
		for(int j=0;j<vertexList.size();j++) {
			if(edges[i][j]==1&&!isVisited[j]) {
				dfs(isVisited, j);
			}
		}
	}
	
	private void dfs() {
		isVisited = new boolean[vertexList.size()];
		System.out.printf(vertexList.get(0)+"\t");
		isVisited[0]=true;
		for(int j=0;j<vertexList.size();j++) {
			if(edges[0][j]==1&&!isVisited[j]) {
				dfs(isVisited, j);
			}
		}
	}
	
	//添加边
	public void insertEdge(int v1,int v2) {
		edges[v1][v2]=1;
		edges[v2][v1]=1;
		numOfEdges++;
	}
}

图的广度优先遍历介绍

广度优先遍历基本思想

1)图的广度优先搜索(Broad First Search)。
2)类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序，以便按这个顺序来访问这些结点的邻接结点

广度优先遍历算法步骤

访问初始结点v并标记结点v为己访问。
结点v入队列
当队列非空时，继续执行，否则算法结束。.
出队列，取得队头结点u。
查找结点 u的第一个邻接结点w。
若结点u的邻接结点w不存在，则转到步骤3; 否则循环执行以下三个步骤:
▶若结点w尚未被访问，则访问结点w并标记为已访问。
▶ 结点w入队列
▶ 查找结点u的继w邻接结点后的下一个邻接结点w，转到步骤6。.

//广度优先遍历
	public void bfs(boolean[] isVisited) {
		LinkedList queue = new LinkedList();
		int i=0;
		System.out.printf(vertexList.get(0)+"\t");
		isVisited[0]=true;
		queue.addLast(i);
		
		while(!queue.isEmpty()) {
			int u = (int) queue.removeFirst();
			for(int j=0;j<vertexList.size();j++) {
				if(edges[u][j]==1&&!isVisited[j]) {
					System.out.printf(vertexList.get(j)+"\t");
					isVisited[j]=true;
					queue.addLast(j);
				}
			}
		}
		
	}
	
	public void bfs() {
		isVisited = new boolean[vertexList.size()];
		bfs(isVisited);
	}

深度优先遍历VS广度优先遍历

在这里插入图片描述

package com.xhl.Graph;

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

public class Graph {

	private ArrayList<String> vertexList;//存储定点集合
	private int[][] edges;//存储邻接矩阵
	private int numOfEdges;//边的数目
	private boolean[] isVisited;//记录节点是否被访问
	
	public static void main(String[] args) {
		int n = 8;
		Graph graph = new Graph(n);
		String vertexs[] = {"1","2","3","4","5","6","7","8"};
		graph.intsertVertex(vertexs);
		
		graph.insertEdge(0, 1);
		graph.insertEdge(0, 2);
		graph.insertEdge(1, 3);
		graph.insertEdge(1, 4);
		graph.insertEdge(2, 5);
		graph.insertEdge(2, 6);
		graph.insertEdge(7, 3);
		graph.insertEdge(7, 4);
		
		graph.dfs();
		System.out.println();
		graph.bfs();
	}
	private void intsertVertex(String[] vertexs){
		for(String vertex:vertexs) {
			vertexList.add(vertex);
		}
	}
	//构造器
	public Graph(int n) {
		edges = new int[n][n];
		vertexList = new ArrayList(n);
		numOfEdges = 0;
	}
	
	//深度遍历
	private void dfs(boolean[] isVisited,int i) {
		System.out.printf(vertexList.get(i)+"\t");
		isVisited[i]=true;
		for(int j=0;j<vertexList.size();j++) {
			if(edges[i][j]==1&&!isVisited[j]) {
				dfs(isVisited, j);
			}
		}
	}
	
	private void dfs() {
		isVisited = new boolean[vertexList.size()];
		System.out.printf(vertexList.get(0)+"\t");
		isVisited[0]=true;
		for(int j=0;j<vertexList.size();j++) {
			if(edges[0][j]==1&&!isVisited[j]) {
				dfs(isVisited, j);
			}
		}
	}
	
	//添加边
	public void insertEdge(int v1,int v2) {
		edges[v1][v2]=1;
		edges[v2][v1]=1;
		numOfEdges++;
	}
	
	//广度优先遍历
	public void bfs(boolean[] isVisited) {
		LinkedList queue = new LinkedList();
		int i=0;
		System.out.printf(vertexList.get(0)+"\t");
		isVisited[0]=true;
		queue.addLast(i);
		
		while(!queue.isEmpty()) {
			int u = (int) queue.removeFirst();
			for(int j=0;j<vertexList.size();j++) {
				if(edges[u][j]==1&&!isVisited[j]) {
					System.out.printf(vertexList.get(j)+"\t");
					isVisited[j]=true;
					queue.addLast(j);
				}
			}
		}
		
	}
	
	public void bfs() {
		isVisited = new boolean[vertexList.size()];
		bfs(isVisited);
	}
}