探索数据结构：图(一)之邻接矩阵与邻接表

✨✨ 欢迎大家来到贝蒂大讲堂✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：数据结构与算法
贝蒂的主页：Betty’s blog

1. 图的定义

**图（Graph）**是数学和计算机科学中的一种基本结构，它由两个主要组成部分定义：顶点集（Vertex Set）V 和边集（Edge Set）E。在一个图$G=(V,E)$中，V 是顶点的有限非空集合，而 E是连接这些顶点之间的边的集合，即每条边都是两个顶点之间的关系。

• 顶点（Vertices）：顶点可以由字母变量表示，比如 V = { v 1 , v 2 , … , v n } V=\{v_1,v_2,\ldots,v_n\} V={v1​,v2​,…,vn​}，$n$ 表示顶点的数量，也称为图的阶或维度。
• 边（Edges）：边是表示顶点间关系的元素，通常表示为 $(u,v)$，这意味着从顶点 $u$ 到顶点 $v$ 有一条边。$E$ 的大小，即 $|E|$，给出了图中边的数量。

注意：线性表有空表，树有空树，但图没有空图。也就是说图不能一个顶点没有，但是边可以为空。

2. 图的基本概念

2.1 有向图与无向图

• 在有向图中，$<x,y>$是有序的，被称为顶点x到顶点y的一条边，$<x,y>$和$<y,x>$是两条不同的边。
• 在无向图中，$(x,y)$是无序的，称为顶点x和顶点y相关联的一条边，这条边没有特定方向，$(x,y)$和$(y,x)$是同一条边。

2.2 完全图

在有n个顶点的无向图中，若有$n\times (n-1)÷2$条边，即任意两个顶点之间都有直接相连的边，则称此图为无向完全图。
在有n个顶点的有向图中，若有$n\times (n-1)$条边，即任意两个顶点之间都有双向的边，则称此图为有向完全图。

2.3 邻接顶点

• 在无向图中，若边$(u,v)$存在于图中，则称$u$和$v$互为邻接顶点，并且边$(u,v)$依附于顶点$u$和顶点$v$。
• 在有向图中，若边$<u,v>$是图中的一条边，则称顶点$u$邻接到顶点$v$，顶点$v$邻接自顶点$u$，同时称边$<u,v>$与顶点$u$和顶点$v$相关联。

2.4 顶点的度

• 在有向图中，顶点的度等于该顶点的入度与出度之和，顶点的入度是以该顶点为终点的边的条数，顶点的出度是以该顶点为起点的边的条数。
• 在无向图中，顶点的度等于与该顶点相关联的边的条数，同时也等于该顶点的入度和出度。

2.5 路径与路径长度

• 若从顶点$v_i$出发有一组边使其可到达顶点$v_j$ ，则称顶点 $v_i$到顶点$v_j$ 的顶点序列为从顶点$v_i$到顶点$v_j$ 的路径。
• 对于不带权的图，一条路径的长度是指该路径上的边的条数；对于带权的图，一条路径的长度是指该路径上各个边权值的总和。其中权值指边附带的数据信息。

2.6 简单路径与回路

• 若路径上的各个顶点$v_1,v_2,v_3...v_n$均不相同，则称这样的路径为简单路径。
• 若路径上第一个顶点与最后一个顶点相同，则称这样的路径为回路或环。

2.7 子图

设图$G=(V,E)$和图$G_1=(V_1,E_1)$，若$V_1\subseteq V$且$E_1\subseteq E$，那么称$G_1$是$G$的子图。

2.8 连通图与强连通图

• 在无向图中，若从顶点 $v_1$ 到顶点 $v_2$ 有路径，则称顶点 $v_1$ 与顶点 $v_2$ 是连通的。如果图中任意一对顶点都是连通的，则称此图为连通图。
• 在有向图中，若每一对顶点 $v_i$ 和 $v_j$ 之间都存在一条从 $v_i$ 到 $v_j$ 的路，也存在一条从 $v_j$ 到 $v_i$ 的路，则称此图是强连通图。

2.9 生成树与最小生成树

• 一个连通图的最小连通子图称为该图的生成树，有$n$个顶点的连通图的生成树有$n$个顶点和$n-1$条边。
• 最小生成树指的是一个图的生成树中，总权值最小的生成树。

3. 图的存储结构

因为图中既有节点，又有边(节点与节点之间的关系)，因此，在图的存储中，只需要保存：节点和边关系即可。 下面我们将介绍两种常见的表示方法：邻接矩阵与邻接表。

3.1 邻接矩阵

邻接矩阵：先用一个数组将定点保存，然后采用矩阵来表示节点与节点之间的关系 。
对于一个具有 $n$个顶点的图 $G=(V,E)$，其中 $V$ 是顶点集，$E$ 是边集。其邻接矩阵$A$是一个 $n\times n$ 的矩阵，定义如下：

• 如果顶点 $i$ 和顶点 $j$ 之间有边相连，那么 $A[i][j]=1$(对于无向图，$A[i][j]=A[j][i]=1$)。
• 如果顶点 $i$ 和顶点 $j$ 之间没有边相连，那么 $A[i][j]=0$(对于无向图，$A[i][j]=A[j][i]=0$)。

例如，对于一个简单的无向图，有三个顶点 V = { v 1 , v 2 , v 3 } V=\{v_1,v_2,v_3\} V={v1​,v2​,v3​}，如果 $v_1$ 和 $v_2$ 之间有边相连，$v_2$ 和 $v_3$ 之间有边相连，$v_1$ 和 $v_3$ 之间没有边相连，那么这个图的邻接矩阵为：$\left[\begin{array}{ccc}0& 1& 0\\ 1& 0& 1\\ 0& 1& 0\end{array}\right]$
如果是对于具有 $n$ 个顶点的带权图 $G=(V,E,W)$，其中 $V$ 是顶点集，$E$ 是边集，$W$ 是权值集合。其邻接矩阵 $A$ 是一个 $n\times n$ 的矩阵。

• 如果顶点 $v_i$ 和顶点 $v_j$ 之间有边相连，那么 $A[i][j]$ 存放着该边对应的权值。
• 如果顶点 $v_i$ 和顶点 $v_j$ 之间没有边相连，那么 $A[i][j]$ 通常被设为一个特定的标识值，比如无穷大或者一个特殊的标记，具体取决于应用场景和算法需求。

例如，有一个带权无向图，三个顶点分别为 $v_1$、$v_2$、$v_3$，$v_1$ 和 $v_2$ 之间边的权值为 2，$v_2$ 和 $v_3$ 之间边的权值为 3，$v_1$ 和 $v_3$ 之间没有边相连。那么这个图的邻接矩阵为：$\left[\begin{array}{ccc}0& 2& \infty \\ 2& 0& 3\\ \infty & 3& 0\end{array}\right]$

3.2 邻接表

邻接表：使用数组表示顶点的集合，使用链表表示边的关系。
对于一个具有$n$个顶点的图$G=(V,E)$，邻接表的主要思想是为每个顶点建立一个链表，链表中存储与该顶点相邻的其他顶点。
具体来说：

• 对于无向图，图中的每一条边$(u,v)$，如果顶点$u$的链表中还没有顶点$v$，则将顶点$v$添加到顶点$u$的链表中；同理，如果顶点$v$的链表中还没有顶点$u$，则将顶点$u$添加到顶点$v$的链表中。
• 对于有向图，图中的每一条边$<u,v>$，只需要将顶点$v$添加到顶点$u$的链表中。

例如，对于一个具有$5$个顶点的无向图，顶点分别为$v_1,v_2,v_3,v_4,v_5$，如果有边$(v_1,v_2)$、$(v_1,v_3)$、$(v_2,v_4)$、$(v_3,v_4)$、$(v_3,v_5)$，那么其邻接表表示如下：

• 顶点$v_1$的链表：$v_2$、$v_3$。
• 顶点$v_2$的链表：$v_1$、$v_4$。
• 顶点$v_3$的链表：$v_1$、$v_4$、$v_5$。
• 顶点$v_4$的链表：$v_2$、$v_3$。
• 顶点$v_5$的链表：$v_3$。

如果是对于一个具有$5$个顶点的有向图，顶点分别为$v_1,v_2,v_3,v_4,v_5$，如果有边$<v_1,v_2>$、$<v_1,v_3>$、$<v_2,v_4>$、$<v_3,v_4>$、$<v_3,v_5>$，那么其邻接表表示如下：

• 顶点$v_1$的链表：$v_2$、$v_3$。
• 顶点$v_2$的链表：$v_4$。
• 顶点$v_3$的链表：$v_4$、$v_5$。
• 顶点$v_4$的链表：没有任何边。
• 顶点$v_5$的链表：没有任何边。

3.3 邻接矩阵与邻接表的优缺点

对于邻接矩阵：

优点：

• 直观性强，邻接矩阵能够$O(1)$的时间判断两个顶点是否相连，并获得相连边的权值。
• 适合稠密图：图中的边越多，邻接矩阵的空间利用率就越高。

缺点：

• 不合适稀疏图：会浪费大量空间。
• 不适合查找一个顶点连接出去的所有边：需要遍历矩阵中对应的一行，该过程的时间复杂度是$O(N)$ ，其中$N$表示的是顶点的个数。

对于邻接表：

优点：

• 适合查找一个顶点连接出去的所有边：只需要遍历对应的链表即可。
• 适合稀疏图：图中的边越少，邻接表存储的空间就越少。

缺点：

• 不合适稠密图：一个顶点会链接大量数据，需要遍历顶点对应位置的链表来确定两点是否相连，该过程的时间复杂度是$O(E)$，其中$E$表示从源顶点连接出去的边的数量。

4. 邻接矩阵与邻接表的实现

4.1 邻接矩阵

4.1.1 邻接矩阵的结构

为了支持所有类型，我们实现一个模版类。其中肯定有两个模版参数V与W分别代表顶点与权值类型，MAX_W表示两个顶点之间没有直接相连的值，一般我们默认为INT_MAX，并且还需要一个bool类型的模版参数Direction代表是有向图还是无向图，false为无向，true为有向。
邻接矩阵的成员变量有三个分别为：数组_vertexs代表边的集合，哈希表_indexMap来映射不同类型与下标的关系，二维数组_matrix代表邻接矩阵。

template<class V, class W, W MAX_W = INT_MAX, bool Direction = false>
class Graph
{
public:
    //构造函数
    Graph(const V*vertexs,int n);
    //获取对应顶点的下标
    int getVertexsIndex(const V& v);
    void addEdge(const V& src, const V& dest, const W& weight);
    //打印顶点集合和邻接矩阵
    void Print();
private:
    vector<V> _vertexs;//顶点集合
    unordered_map<V, int> _indexMap;//映射关系
    vector<vector<W>> _matrix;//邻接矩阵
};

4.1.2 邻接矩阵的初始化

我们首先顶点集合全部初始化，然后将邻接矩阵的值全设为INT_MAX，最后将顶点集合与下标建立映射关系。

//构造函数
Graph(const V*vertexs,int n)
    :_vertexs(vertexs, vertexs + n)
    , _matrix(n,vector<int>(n, MAX_W))
{
    //映射下标
    for (int i = 0; i < n; i++)
    {
        _indexMap[vertexs[i]] = i;
    }
}

4.1.3 添加边

添加边之前我们需要先找到对应顶点的下标，如果找不到需要抛异常。然后根据对应下标更新邻接矩阵，如果是无向图继续更新。

//获取对应顶点的下标
int getVertexsIndex(const V& v)
{
    auto it = _indexMap.find(v);
    if (it == _indexMap.end())
    {
        throw invalid_argument("不存在的顶点");
        return -1;
    }
    else
    {
        return it->second;//返回对应下标
    }
}
//添加边
void addEdge(const V& src, const V& dest, const W& weight)
{
    int srci = getVertexsIndex(src);//获取起始点下标
    int desti = getVertexsIndex(dest);//获取终点下标
    _matrix[srci][desti] = weight;
    if (Direction == false)
    {
        _matrix[desti][srci] = weight;//无向图
    }
}

4.1.4 打印邻接矩阵

最后我们打印邻接矩阵，方便测试程序的正误。

//打印顶点集合和邻接矩阵
void Print() 
{
	int n = _vertexs.size();
	//打印顶点集合
	for (int i = 0; i < n; i++) {
		cout << "[" << i << "]->" << _vertexs[i] << endl;
	}
	cout << endl;
	//打印邻接矩阵
	cout << "  ";
	for (int i = 0; i < n; i++) {
		printf("%4d", i);
	}
	cout << endl;
	for (int i = 0; i < n; i++) {
		cout << i << " "; //竖下标
		for (int j = 0; j < n; j++) {
			if (_matrix[i][j] == MAX_W) {
				printf("%4c", '*');
			}
			else {
				printf("%4d", _matrix[i][j]);
			}
		}
		cout << endl;
	}
}

4.2 邻接表

4.2.1 邻接表的结构

同样邻接表我们编写成一个模板类，相比与邻接矩阵我们可以不需要代表权值最大的MAX_W。并且为了方便描述我们需要首先编写一个关于边Edge的类。这个类包含起始与终点下标，已经对应的权值。
然后邻接表中有三个成员变量：数组_vertexs代表边的集合，哈希表indexMap来映射不同类型与下标的关系，数组_linkTable代表邻接矩阵。

template<class W>
//边
struct Edge
{
    int _srci;//起始下标
    int _desti;//终点下标
    W _w;//权值
    Edge<W>* _next;
    Edge(int srci,int desti,const W&w)
        :_srci(srci)
        ,_desti(desti)
        ,_w(w)
        ,_next(nullptr)
    {}
};
template<class V, class W, bool Direction = false>
class Graph
{
    typedef Edge<W> Edge;
public:
    //构造函数
    Graph(const V* vertexs, int n);
    //获取对应顶点的下标
    int getVertexsIndex(const V& v);
    //添加边
    void addEdge(const V& src, const V& dest, const W& weight);
    //打印顶点集合和邻接表
    void Print();
private:
    vector<V> _vertexs;//顶点集合
    unordered_map<V, int> _indexMap;//映射关系
    vector<Edge*> _linkTable;//邻接矩阵
};

4.2.2 邻接表的初始化

我们首先顶点集合全部初始化，然后将邻接表的值全设为nullptr，最后将顶点集合与下标建立映射关系；

//构造函数
Graph(const V* vertexs, int n)
    :_vertexs(vertexs, vertexs + n)
    , _linkTable(n, nullptr)
{
    //映射下标
    for (int i = 0; i < n; i++)
    {
        _indexMap[vertexs[i]] = i;
    }
}

4.2.3 添加边

添加边之前我们需要先找到对应顶点的下标，如果找不到需要抛异常。然后根据对应下标更新邻接矩阵，如果是无向图继续更新。

//获取对应顶点的下标
int getVertexsIndex(const V& v)
{
	auto it = _indexMap.find(v);
	if (it == _indexMap.end())
	{
		throw invalid_argument("不存在的顶点");
		return -1;
	}
	else
	{
		return it->second;//返回对应下标
	}
}
//添加边
void addEdge(const V& src, const V& dest, const W& weight)
{
	int srci = getVertexsIndex(src);//获取起始点下标
	int desti = getVertexsIndex(dest);//获取终点下标
	Edge* sre = new Edge(srci, desti, weight);
	//进行头插
	sre->_next = _linkTable[srci];
	_linkTable[srci] = sre;
	if (Direction == false)
	{
		Edge* dese = new Edge(desti, srci, weight);
		dese->_next = _linkTable[desti];
		_linkTable[desti] = dese;
	}
}

4.2.4 打印邻接矩阵

最后我们打印邻接表，方便测试程序的正误。

//打印顶点集合和邻接表
void Print()
{
	int n = _vertexs.size();
	//打印顶点集合
	for (int i = 0; i < n; i++) {
		cout << "[" << i << "]->" << _vertexs[i] << " ";
	}
	cout << endl << endl;

	//打印邻接表
	for (int i = 0; i < n; i++) {
		Edge* cur = _linkTable[i];
		cout << "[" << i << ":" << _vertexs[i] << "]->";
		while (cur) {
			cout << "[" << cur->_desti << ":" << _vertexs[cur->_desti] << ":" << cur->_w << "]->";
			cur = cur->_next;
		}
		cout << "nullptr" << endl;
	}
}

5. 源码

5.1 邻接矩阵

namespace Matrix
{
	template<class V, class W, W MAX_W = INT_MAX, bool Direction = false>
	class Graph
	{
	public:
		//构造函数
		Graph(const V*vertexs,int n)
			:_vertexs(vertexs, vertexs + n)
			, _matrix(n,vector<int>(n, MAX_W))
		{
			//映射下标
			for (int i = 0; i < n; i++)
			{
				_indexMap[vertexs[i]] = i;
			}
		}
		//获取对应顶点的下标
		int getVertexsIndex(const V& v)
		{
			auto it = _indexMap.find(v);
			if (it == _indexMap.end())
			{
				throw invalid_argument("不存在的顶点");
				return -1;
			}
			else
			{
				return it->second;//返回对应下标
			}
		}
		//添加边
		void addEdge(const V& src, const V& dest, const W& weight)
		{
			int srci = getVertexsIndex(src);//获取起始点下标
			int desti = getVertexsIndex(dest);//获取终点下标
			_matrix[srci][desti] = weight;
			if (Direction == false)
			{
				_matrix[desti][srci] = weight;//无向图
			}
		}
		//打印顶点集合和邻接矩阵
		void Print() {
			int n = _vertexs.size();
			//打印顶点集合
			for (int i = 0; i < n; i++) {
				cout << "[" << i << "]->" << _vertexs[i] << endl;
			}
			cout << endl;
			//打印邻接矩阵
			cout << "  ";
			for (int i = 0; i < n; i++) {
				printf("%4d", i);
			}
			cout << endl;
			for (int i = 0; i < n; i++) {
				cout << i << " "; //竖下标
				for (int j = 0; j < n; j++) {
					if (_matrix[i][j] == MAX_W) {
						printf("%4c", '*');
					}
					else {
						printf("%4d", _matrix[i][j]);
					}
				}
				cout << endl;
			}
		}
	private:
		vector<V> _vertexs;//顶点集合
		unordered_map<V, int> _indexMap;//映射关系
		vector<vector<W>> _matrix;//邻接矩阵
	};
}

5.2 邻接表

namespace LinkTable
{
	template<class W>
	struct Edge
	{
		int _srci;//起始下标
		int _desti;//终点下标
		W _w;//权值
		Edge<W>* _next;
		Edge(int srci,int desti,const W&w)
			:_srci(srci)
			,_desti(desti)
			,_w(w)
			,_next(nullptr)
		{}
	};
	template<class V, class W, bool Direction = false>
	class Graph
	{
		typedef Edge<W> Edge;
	public:
		//构造函数
		Graph(const V* vertexs, int n)
			:_vertexs(vertexs, vertexs + n)
			, _linkTable(n, nullptr)
		{
			//映射下标
			for (int i = 0; i < n; i++)
			{
				_indexMap[vertexs[i]] = i;
			}
		}
		//获取对应顶点的下标
		int getVertexsIndex(const V& v)
		{
			auto it = _indexMap.find(v);
			if (it == _indexMap.end())
			{
				throw invalid_argument("不存在的顶点");
				return -1;
			}
			else
			{
				return it->second;//返回对应下标
			}
		}
		//添加边
		void addEdge(const V& src, const V& dest, const W& weight)
		{
			int srci = getVertexsIndex(src);//获取起始点下标
			int desti = getVertexsIndex(dest);//获取终点下标
			Edge* sre = new Edge(srci, desti, weight);
			//进行头插
			sre->_next = _linkTable[srci];
			_linkTable[srci] = sre;
			if (Direction == false)
			{
				Edge* dese = new Edge(desti, srci, weight);
				dese->_next = _linkTable[desti];
				_linkTable[desti] = dese;
			}
		}
		//打印顶点集合和邻接表
		void Print()
		{
			int n = _vertexs.size();
			//打印顶点集合
			for (int i = 0; i < n; i++) {
				cout << "[" << i << "]->" << _vertexs[i] << " ";
			}
			cout << endl << endl;

			//打印邻接表
			for (int i = 0; i < n; i++) {
				Edge* cur = _linkTable[i];
				cout << "[" << i << ":" << _vertexs[i] << "]->";
				while (cur) {
					cout << "[" << cur->_desti << ":" << _vertexs[cur->_desti] << ":" << cur->_w << "]->";
					cur = cur->_next;
				}
				cout << "nullptr" << endl;
			}
		}

	private:
		vector<V> _vertexs;//顶点集合
		unordered_map<V, int> _indexMap;//映射关系
		vector<Edge*> _linkTable;//邻接矩阵
	};
}