【数据结构】18.图（Graph）

卡戎-caryon

于 2024-09-02 17:55:51 发布

阅读量433

点赞数 6

分类专栏：数据结构文章标签：数据结构图论

本文链接：https://blog.csdn.net/2301_80258336/article/details/141685293

版权

数据结构专栏收录该内容

18 篇文章 0 订阅

订阅专栏

一、图的基本概念

图是由顶点集合及顶点间的关系组成的一种数据结构：G = (V， E)，其中：V = {x|x属于某个数据对象集}是有穷非空集合；E = {(x,y)|x,y属于V}或者E = {<x, y>|x,y属于V && Path(x, y)}是顶点间关系的有穷集合，也叫做边的集合。

注意:线性表可以是空表，树可以是空树，但图不可以是空图。就是说，图中不能一个顶点也没有，图的顶点集V一定非空，但边集E可以为空，此时图中只有顶点而没有边。

顶点：图中结点称为顶点
边：两个顶点vi和vj相关联称作顶点vi和顶点vj之间有一条边
无向图：在无向图中，顶点对(x, y)是无序的，顶点对(x,y)称为顶点x和顶点y相关联的一条边，这条边没有特定方向，(x，y)和(y，x)是同一条边，比如下图G1和G2为无向图。注意：无向边(x, y)等于有向边<x, y>和<y, x>。
有向图：在有向图中，顶点对<x, y>是有序的，顶点对<x，y>称为顶点x到顶点y的一条边(弧)，<x, y>和<y, x>是两条不同的边，比如下图G3和G4为有向图。

在这里插入图片描述
无向完全图：在有n个顶点的无向图中，若有n * (n-1)/2条边，即任意两个顶点之间有且仅有一条边，则称此图为无向完全图，比如上图G1；
有向完全图：在n个顶点的有向图中，若有n * (n-1)条边，即任意两个顶点之间有且仅有方向相反的边，则称此图为有向完全图，比如上图G4。
邻接顶点：在无向图中G中，若(u, v)是E(G)中的一条边，则称u和v互为邻接顶点，并称边(u,v)依附于顶点u和v；在有向图G中，若<u, v>是E(G)中的一条边，则称顶点u邻接到v，顶点v邻接自顶点u，并称边<u, v>与顶点u和顶点v相关联。
顶点的度：顶点v的度是指与它相关联的边的条数，记作deg(v)。在有向图中，顶点的度等于该顶点的入度与出度之和，其中顶点v的入度是以v为终点的有向边的条数，记作indev(v);顶点v的出度是以v为起始点的有向边的条数，记作outdev(v)。因此：dev(v) = indev(v) + outdev(v)。注意：对于无向图，顶点的度等于该顶点的入度和出度，即dev(v) = indev(v) = outdev(v)。
路径：在图G = (V， E)中，若从顶点vi出发有一组边使其可到达顶点vj，则称顶点vi到顶点vj的顶点序列为从顶点vi到顶点vj的路径。
路径长度：对于不带权的图，一条路径的路径长度是指该路径上的边的条数；对于带权的图，一条路径的路径长度是指该路径上各个边权值的总和。
在这里插入图片描述
简单路径与回路：若路径上各顶点v1，v2，v3，…，vm均不重复，则称这样的路径为简单路径。若路径上第一个顶点v1和最后一个顶点vm重合，则称这样的路径为回路或环。

子图：设图G = {V, E}和图G1 = {V1，E1}，若V1属于V且E1属于E，则称G1是G的子图。
在这里插入图片描述
连通图：在无向图中，若从顶点v1到顶点v2有路径，则称顶点v1与顶点v2是连通的。如果图中任意一对顶点都是连通的，则称此图为连通图。
强连通图：在有向图中，若在每一对顶点vi和vj之间都存在一条从vi到vj的路径，也存在一条从vj到vi的路径，则称此图是强连通图。
生成树：一个连通图的最小连通子图称作该图的生成树。有n个顶点的连通图的生成树有n个顶点和n-1条边。

二、图的存储结构

因为图中既有节点，又有边(节点与节点之间的关系)，因此，在图的存储中，只需要保存节点和边关系即可

2.1 邻接矩阵

因为节点与节点之间的关系就是连通与否，即为0或者1，因此邻接矩阵(二维数组)即是：先用一个数组将定点保存，然后采用矩阵来表示节点与节点之间的关系
在这里插入图片描述
注意：
1. 无向图的邻接矩阵是对称的，第i行(列)元素之和，就是顶点i的度。有向图的邻接矩阵则不一定是对称的，第i行(列)元素之后就是顶点i 的出(入)度。
2. 如果边带有权值，并且两个节点之间是连通的，上图中的边的关系就用权值代替，如果两个顶点不通，则使用无穷大代替。
3. 用邻接矩阵存储图的有点是能够快速知道两个顶点是否连通，缺陷是如果顶点比较多，边比较少时，矩阵中存储了大量的0成为系数矩阵，比较浪费空间，并且要求两个节点之间的路径不是很好求。
在这里插入图片描述

#pragma once

#include<vector>
#include<map>
#include<iostream>
using namespace std;

//		顶点类型，权重类型                             有无方向
template<class V,class W ,W W_MAX=INT_MAX,bool Direction=false>
class Graph
{
public:
	//构造函数：使用顶点数组进行初始化
	Graph(const V* arr,size_t n)
	{
		//初始化顶点集
		_vertex.resize(n);
		for (size_t i = 0; i < n; i++)
		{
			_vertex[i] = arr[i];//存储顶点信息
			_Index[arr[i]] = i;//顶点映射的下标
		}
		//初始化权值矩阵
		_matrix.resize(n);
		for (size_t i = 0; i < n; i++)
			_matrix[i].resize(n,W_MAX);
	}
	//获取对应下标
	size_t GetIndex(const V& src)
	{
		//一般来说不太可能找不到
		auto ret = _Index.find(src);
		if (ret != _Index.end())
			return ret->second;
		else
			return -1;
	}
	//添加边
	void AddEdge(const V& src, const V& dst,const W& weight)
	{
		//换成下标
		size_t srci = GetIndex(src);
		size_t dsti = GetIndex(dst);
		
		_matrix[srci][dsti] = weight;

		if (!Direction)
		{
			_matrix[dsti][srci] = weight;
		}
	}
	//打印一下关系
	void Print()
	{
		//打印顶点与下标的映射关系
		for (size_t i = 0; i < _vertex.size(); i++)
		{
			cout << "[" << i << "]->" << _vertex[i] << endl;
		}
		for (size_t i = 0; i < _matrix.size(); i++)
		{
			for (size_t j = 0; j < _matrix[i].size(); j++)
			{
				if (_matrix[i][j] == W_MAX)
					cout << "* " << " ";
				else
					cout << _matrix[i][j] << " ";
			}
			cout << endl;
		}
	}
private:
	vector<V> _vertex;//顶点集
	map<V, size_t> _Index;//顶点所对应的下标
	vector<vector<W>> _matrix;//权值矩阵（边矩阵）
};

2.1 邻接表

邻接表：使用数组表示顶点的集合，使用链表表示边的关系。

三、图的遍历

3.1 图的广度优先遍历

//广度优先遍历
void BFS(const V& src)
{
	//获取下标
	size_t srci = GetIndex(src);
	//标记数组，标记访问过的元素
	vector<bool> visited(_vertex.size(), false);
	visited[srci] = true;
	//利用队列实现
	queue<size_t> q;
	q.push(srci);
	size_t LevelSize = q.size();
	while (!q.empty())
	{
		//一层一层出
		while (LevelSize--)
		{
			//取队头元素
			size_t front = q.front();
			//输出当前信息
			cout << _vertex[front] << " ";
			q.pop();
			//把与它相邻的顶点入队列
			for (size_t i = 0; i < _vertex.size(); i++)
			{
				if (_matrix[front][i] != W_MAX&&visited[i]==false)
				{
					q.push(i);
					visited[i] = true;
				}
			}
		}
		//获取下一层数据个数
		LevelSize = q.size();
		cout << endl;
	}
	cout << endl;
}

3.2 图的深度优先遍历

void _DFS(size_t srci, vector<bool>& visited)
{
	cout << _vertex[srci] << " ";
	visited[srci] = true;
	for (size_t i = 0; i < _vertex.size(); i++)
	{
		if (_matrix[srci][i] != W_MAX && visited[i] == false)
			_DFS(i, visited);
	}
}
//DFS
void DFS(const V& src)
{
	//获取下标
	size_t srci = GetIndex(src);
	//标记数组
	vector<bool> visited(_vertex.size(), false);
	//递归
	_DFS(srci, visited);

	//解决不连通的情况
	for (size_t i = 0; i < _vertex.size(); i++)
	{
		if (visited[i] == false)
			_DFS(i, visited);
	}
}

四、最小生成树

连通图中的每一棵生成树，都是原图的一个极大无环子图，即：从其中删去任何一条边，生成树就不在连通；反之，在其中引入任何一条新边，都会形成一条回路。
若连通图由n个顶点组成，则其生成树必含n个顶点和n-1条边。因此构造最小生成树的准则有三条：
1. 只能使用图中的边来构造最小生成树
2. 只能使用恰好n-1条边来连接图中的n个顶点
3. 选用的n-1条边不能构成回路

构造最小生成树的方法：Kruskal算法和Prim算法。这两个算法都采用了逐步求解的贪心策略。

贪心算法：是指在问题求解时，总是做出当前看起来最好的选择。也就是说贪心算法做出的不是整体最优的的选择，而是某种意义上的局部最优解。贪心算法不是对所有的问题都能得到整体最优解。

4.1 Kruskal 算法

任给一个有n个顶点的连通网络N={V,E}，首先构造一个由这n个顶点组成、不含任何边的图G={V,NULL}，其中每个顶点自成一个连通分量，其次不断从E中取出权值最小的一条边(若有多条任取其一)，若该边的两个顶点来自不同的连通分量，则将此边加入到G中。如此重复，直到所有顶点在同一个连通分量上为止。

核心：每次迭代时，选出一条具有最小权值，且两端点不在同一连通分量上的边，加入生成树。

下图摘自《算法导论》
在这里插入图片描述

//边
struct Edge
{
	size_t _srci;
	size_t _dsti;
	W _weight;

	Edge(size_t srci, size_t dsti, W& weight):_srci(srci),_dsti(dsti),_weight(weight){}
	bool operator>(const Edge& e) const
	{
		return _weight > e._weight;
	}
};
//最小生成树：Kruskal算法
W Kruskal(Graph& minTree)
{
	//初始化最小生成树
	minTree._vertex = _vertex;
	minTree._Index = _Index;
	minTree._matrix.resize(_vertex.size());
	for (size_t i = 0; i < _vertex.size(); i++)
		minTree._matrix[i].resize(_vertex.size(),W_MAX);

	//每次都选取权值最小的边
	priority_queue<Edge, vector<Edge>, greater<Edge>> pqmin;
	//建立小根堆
	size_t size = _vertex.size();
	for (size_t i = 0; i < size; i++)
	{
		for (size_t j = i; j < size; j++)
		{
			if (_matrix[i][j] != W_MAX)
				pqmin.push(Edge(i, j, _matrix[i][j]));
		}
	}
	size_t n = 0;
	W total = W(); //总的权重
	//使用并查集判断两个顶点是否在一个集合
	UnionFindSet ufs(_vertex.size());
	
	//找到n-1条边建立minTree
	while (!pqmin.empty())
	{
		//取最小边建立联系
		Edge min = pqmin.top();
		pqmin.pop();
		//不在同一个集合可以建边
		if(!ufs.IsSameSet(min._srci,min._dsti))
		{
			cout << _vertex[min._srci] << "->" << _vertex[min._dsti] <<":"<<min._weight << endl;
			minTree._AddEdge(min._dsti, min._dsti,min._weight);
			ufs.UnionSet(min._srci, min._dsti);
			n++;
			total += min._weight;
		}
	}
	//建立了n-1条边就返回权重
	if (n == _vertex.size() - 1)
		return total;
	else
		return W();
}

4.2 Prim 算法

在这里插入图片描述

//边
struct Edge
{
	size_t _srci;
	size_t _dsti;
	W _weight;

	Edge(size_t srci, size_t dsti, W& weight):_srci(srci),_dsti(dsti),_weight(weight){}
	bool operator>(const Edge& e) const
	{
		return _weight > e._weight;
	}
};
//最小生成树：Prim算法
W Prim(Graph& minTree,const V&src)
{
	//获取下标
	size_t srci = GetIndex(src);
	//初始化最小生成树
	minTree._vertex = _vertex;
	minTree._Index = _Index;
	minTree._matrix.resize(_vertex.size());
	for (size_t i = 0; i < _vertex.size(); i++)
		minTree._matrix[i].resize(_vertex.size(), W_MAX);
	//判断是否在一个集合
	UnionFindSet ufs(_vertex.size());
	//建小堆
	priority_queue<Edge, vector<Edge>, greater<Edge>> minque;
	//把与srci相邻的顶点所构成的边都添加到小堆里
	for (size_t i = 0; i < _vertex.size(); i++)
	{
		if (_matrix[srci][i] != W_MAX)
			minque.push(Edge(srci, i, _matrix[srci][i]));
	}
	
	int n = 0;
	W total = W();
	//循环选边
	while (!minque.empty())
	{
		//取出当前最小的边
		Edge min = minque.top();
		minque.pop();
		//判断是否构成环
		if (!ufs.IsSameSet(min._srci, min._dsti))
		{
			cout << _vertex[min._srci] << "->" << _vertex[min._dsti] << ":" << min._weight << endl;

			minTree._AddEdge(min._srci, min._dsti, _matrix[min._srci][min._dsti]);
			ufs.UnionSet(min._srci, min._dsti);
			n++;
			total += _matrix[min._srci][min._dsti];
			//相邻的边进入小堆
			for (size_t i = 0; i < _vertex.size(); i++)
			{
				if(_matrix[min._dsti][i] != W_MAX)
					minque.push(Edge(min._dsti, i, _matrix[min._dsti][i]));
			}
		}
	}
	//建立了n-1条边就返回权重
	if (n == _vertex.size() - 1)
		return total;
	else
		return W();
}

五、最短路径

最短路径问题：从在带权有向图G中的某一顶点出发，找出一条通往另一顶点的最短路径，最短也就是沿路径各边的权值总和达到最小。

5.1单源最短路径 – Dijkstra 算法

在这里插入图片描述

	//最短路径算法：Dijkstra算法
	//源点 权值数组 父路径数组
	void Dijkstra(const V& src,vector<W>& dist,vector<int>& parentPath)
	{
		//获取下标
		size_t srci = GetIndex(src);
		//顶点个数
		size_t n = _vertex.size();
		//初始化距离数组，父路径数组
		dist.resize(n, W_MAX);
		parentPath.resize(n, -1);
		//对源点记录
		dist[srci] = 0;
		parentPath[srci] = srci;
		//标记数组
		vector<bool> visited(n, false);
		//更新剩余点位
		for(size_t j=0;j<n;j++)
		{
			size_t cur = 0;
			//找距离srci最短的顶点,更新最短路径
			W min = W_MAX;//最短距离
			for (size_t i = 0; i < n; i++)
			{
				if (visited[i]==false&&dist[i]< min)
				{
					min = dist[i];
					cur = i;
				}
			}
			visited[cur] = true;//标记
			//松弛操作
			for (size_t i = 0; i < n; i++)
			{
				if (visited[j] == false && _matrix[cur][i] != W_MAX && dist[cur] + _matrix[cur][i] < dist[i])
				{
					dist[i] = dist[cur] + _matrix[cur][i];
					parentPath[i] = cur;
				}
			}
		}
	}