数据结构进阶1（图）

学程序的羊

已于 2024-10-02 23:11:30 修改

阅读量365

点赞数 11

文章标签：数据结构学习 c++ 广度优先深度优先图搜索算法算法

于 2024-10-02 22:56:53 首次发布

本文链接：https://blog.csdn.net/weixin_72426758/article/details/142301776

版权

图的学习

一.并查集
- 了解并查集
- 实现并查集
图

一.并查集

了解并查集

class UnionFindSet {
public:
	UnionFindSet(size_t n)
		:_ufs(n,-1)
	{}
		void Union(size_t x1, size_t x2)
	{}
	int FindRoot(size_t x)
	{}
	bool InSet(size_t x1,size_t x2)
	{}
	size_t SizeSet()
	{}
private:
	vector<int> _ufs;
};

在这里插入图片描述

下标为负数这个下标为集合的根，存的值为该集合的拥有的数据个数。
下标存的若为非负数即为它的父亲节点的下标。
有多少个负数即有多少个集合

实现并查集

Union合并两个下标对应的两个集合

	void Union(size_t x1, size_t x2)
	{
		//寻找两个集合的根
		int root1 = FindRoot(x1), root2 = FindRoot(x2);
		//根下标相等说明在同一集合，无需在合并
		if (x1 == x2)return;
		if (root1 > root2)	swap(root1, root2);
		//将root2下的节点放到root1下
		_ufs[root1] += _ufs[root2];
		_ufs[root2] = root1;
	}

FindRoot查找某下标所在集合的根下标

	int FindRoot(size_t x)
	{
		//根据下标位置存的非负值为父亲节点找根
		int root = x;
		while (_ufs[root] >= 0)
		{
			root = _ufs[root];
		}
		//压缩路径
		//将x节点的所有非根祖先都直接挂到根节点下
		int parent = _ufs[x];
		while (parent >= 0)
		{
			_ufs[x] = root;
			x = parent;
			parent = _ufs[x];
		}
		//压缩路径这里为优化可以省略
		
		return root;
	}

InSet判断两个数是否在同一集合下

	bool InSet(size_t x1,size_t x2)
	{
		return FindRoot(x1) == FindRoot(x2);
	}

SizeSet返回数组中负数的个数，即为集合的个数

	size_t SizeSet()
	{
		int count = 0;
		for (size_t i = 0;i < _ufs.size();i++)
		{
			if (i < 0) ++count;
		}
		return count;
	}

练习: 等式方程的可满足性
可以使用并查集解决

class Solution {
public:
    bool equationsPossible(vector<string>& equations) {
        vector<int> ufs(26, -1);
        auto FindRoot = [&](int x)->int{
            int root = x;
            while(ufs[root] >= 0)
            {
                root = ufs[root];
            }
            return root;
        };
        auto InSet = [&](int x,int y)->bool{
            return FindRoot(x) == FindRoot(y);
        };
        auto Union = [&](int x, int y)->void{
            int rootX = FindRoot(x);
            int rootY = FindRoot(y);
            if(rootX == rootY) return;
            ufs[rootX] += ufs[rootY];
            ufs[rootY] = rootX;
        };
        for (string s : equations) {
            if (s[1] == '=')
            Union(s[0]-'a',s[3]-'a');
        }
        for (string s : equations) {
            if (s[1] == '!')
                if (InSet(s[0] - 'a', s[3] - 'a'))
                    return false;
        }
        return true;
    }
};

图

二.什么是图

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

顶点和边：图中结点称为顶点，第i个顶点记作vi。两个顶点vi和vj相关联称作顶点vi和顶点vj之间有一条边，图中的第k条边记作ek，ek = (vi，vj)或<vi，vj>。

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

完全图：在有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个顶点和n1条边。

三.如何构建图

1.邻接矩阵

节点与节点之间的关系就是连通与否，即为0或者1，因此邻接矩阵(二维数组)即是：先用一个数组将定点保存，然后采用矩阵来表示节点与节点之间的关系。

注意：

1. 无向图的邻接矩阵是对称的，第i行(列)元素之和，就是顶点i的度。有向图的邻接矩阵则不一定是对称的，第i行(列)元素之后就是顶点i 的出(入)度。
1. 如果边带有权值，并且两个节点之间是连通的，上图中的边的关系就用权值代替，如果两个顶点不通，则使用无穷大代替。
1. 用邻接矩阵存储图的有点是能够快速知道两个顶点是否连通，缺陷是如果顶点比较多，边比较少时，矩阵中存储了大量的0成为系数矩阵，比较浪费空间，并且要求两个节点之间的路径不是很好求。

//Graph.h
#pragma once
#include<vector>
#include<map>

namespace AdMatrix {
	template<class V, class W,W MAX_W = INT_MAX,bool Direction = true>
	class Graph {
	public:
			//此结构在后面最小生成树时需要
			struct Edge {
		public:
			size_t _srci;
			size_t _dsti;
			W _w;
			Edge(size_t srci, size_t dsti,const W& w)
			{
				_srci = srci;
				_dsti = dsti;
				_w = w; 
			}
			bool operator>(const Edge& e)const
			{
				return _w > e._w;
			}
			bool operator<(const Edge& e)
			{
				return _w < e->_w;
			}
		};
		//1.IO输入，适合OJ题
		//2.文件读取
		//3.手动输入边录入 ->此处选择
		Graph(const V* arr, size_t n)
		{
			_vertexs.reserve(n);
			for (int i = 0; i < n; i++)
			{
				_vertexs.push_back(arr[i]);
				_indexMap[arr[i]] = i;
			}
			_matrix.resize(n);
			for (int i = 0; i < n; i++)
			{
				for (int j = 0; j < n; j++)
				{
					_matrix[i].push_back(MAX_W);
				}
			}
		}
		int GetVertexIndex(const V& x)
		{
			auto it = _indexMap.find(x);
			if (it == _indexMap.end())
			{
				throw invalid_argument("顶点不存在");
				return -1;
			}
			return it->second;
		}
		bool AddEdge(const V& src,const V& dst,const W& w)
		{
			if(GetVertexIndex(src) == -1 || GetVertexIndex(dst) == -1) return false;
			int x = _indexMap[src],y = _indexMap[dst];
			_matrix[x][y] = w;
			if(!Direction)_matrix[y][x] = w;
			return true;
		}
		void print()
		{
			cout << "   ";
			for (int i = 0; i < _matrix.size(); i++)
			{
				printf("%d ", i);
			}
			cout << endl;
			for (int i = 0;i < _matrix.size();i++)
			{
				printf("%d: ", i);
				for (int j = 0;j < _matrix.size(); j++)
				{
					if (_matrix[i][j] == MAX_W) cout << "x ";
					else cout << _matrix[i][j] << " ";
				}
				cout << endl;
			}
		}
	private:
		std::vector<V> _vertexs;
		std::map<V, int> _indexMap;
		std::vector<std::vector<W>> _matrix;
	};
};

//main.cpp
#include<iostream>
using namespace std;
#include"Graph.h"

void Mtext()
{
	AdMatrix::Graph<char,int,INT_MAX,true> g("0123", 4);
	g.AddEdge('0', '1', 1);
	g.AddEdge('0', '3', 4);
	g.AddEdge('1', '3', 2);
	g.AddEdge('1', '2', 9);
	g.AddEdge('2', '3', 8);
	g.AddEdge('2', '1', 5);
	g.AddEdge('2', '0', 3);
	g.AddEdge('3', '2', 6);
	g.print();
}
int main()
{
	Mtext();
	return 0;
}

输出结果

2.邻接表

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

注意：

无向图中同一条边在邻接表中出现了两次。如果想知道顶点vi的度，只需要知道顶点vi边链表集合中结点的数目即可。
有向图中每条边在邻接表中只出现一次，与顶点vi对应的邻接表所含结点的个数，就
是该顶点的出度，也称出度表，要得到vi顶点的入度，必须检测其他所有顶点对应的边链表，看有多少边顶点的dst取值是i。

//Graph.h
#pragma once
#include<vector>
#include<map>
#include<list>
namespace AdList {
	template<class V, class W, bool Direction = true>
	class Graph {
	public:
		Graph(const V* arr, size_t n)
		{
			_vertexs.reserve(n);
			for (int i = 0; i < n; i++)
			{
				_vertexs.push_back(arr[i]);
				_indexMap[arr[i]] = i;
			}
			_matrix.resize(n);
		}
		int GetVertexIndex(const V& x)
		{
			auto it = _indexMap.find(x);
			if (it == _indexMap.end())
			{
				throw invalid_argument("顶点不存在");
				return -1;
			}
			return it->second;
		}
		bool AddEdge(const V& src, const V& dst, const W& w)
		{
			if(GetVertexIndex(src) == -1 || GetVertexIndex(dst) == -1) return false;

			int x = _indexMap[src], y = _indexMap[dst];
			_matrix[x].push_back(std::make_pair(_vertexs[y],w));
			
			if (!Direction)
				_matrix[y].push_back(std::make_pair(_vertexs[x],w));
			return true;
		}
		void print()
		{
			for (int i = 0; i < _matrix.size(); i++)
			{
				cout << "[" << i << "]" << _vertexs[i] << ": ";
				auto it = _matrix[i].begin();
				while (it != _matrix[i].end())
				{
					cout << it->first << "|" << it->second << " -> ";
					++it;
				}
				cout << "NULL";
				cout << endl;
			}
		}
	private:
		std::vector<V> _vertexs;
		std::map<V, int> _indexMap;
		std::vector<std::list<std::pair<V,W>>> _matrix;
	};
};

//main.cpp
#include<iostream>
using namespace std;
#include"Graph.h"

void Ltext()
{
	string a[] = { "张三", "李四", "王五", "赵六" };
	AdList::Graph<string,int,true> g1(a, 4);
	g1.AddEdge("张三", "李四", 100);
	g1.AddEdge("张三", "王五", 200);
	g1.AddEdge("王五", "赵六", 30);
	g1.print();
}
int main()
{
	Ltext();
	return 0;
}

输出结果

四.图的遍历

1.图的广度优先遍历（BFS）

思路：

准备一个队列要遍历的节点放进去,一个遍历数组记录遍历过的数字。
从节点A开始遍历，A进队列，在数组中将A设置已遍历。
将A出队列，把与A相连且数组中为未遍历的的节点入队列即B,C,D入队列。
再B,C,D分别出队列带来相连且为遍历节点 ,重复操作直至队列为空结束。

		void BFS(const V& x)
		{
			std::queue<V> q;
			std::vector<int> m(_vertexs.size(),0);
			//分层获取数据，第一层初始为1。
			int levelSize = 1;
			q.push(x);
			m[_indexMap[x]] = 1;

			while (!q.empty())
			{
				//分层获取数据。
				for (int ls = 0;ls < levelSize;ls++)
				{
					V tmp = q.front();
					q.pop();

					//遍历取到值，获取的数据可以进行各种操作这里就只是打印了。
					cout << tmp << " ";
					//

					int index = _indexMap[tmp];
					for (int i = 0; i < _matrix[index].size(); i++)
					{
						if (_matrix[index][i] != MAX_W && !m[i])
						{
								q.push(_vertexs[i]);
								m[i] = 1;
						}
					}
				}
				//上一层出队列都会带来下一层的节点，levelSize又为上一层的节点数
				//所以上一层出完就会带来所有的下一层节点，得出队列长度即为下一层的节点数
				levelSize = q.size();
			}
		}

以上代码只能遍历连通图，若图不为连通图，只需将BFS遍历方法放进一个子函数，将记录已遍历数组中未遍历的节点再调用子函数即可

		void BFS(const V& x)
		{
			int n = _vertexs.size();
			vector<int> m(n,0);
			_BFS(x, m);
			for (int i = 0; i < n; i++)
				if (m[i] == 0)
					_BFS(_vertexs[i],m);
		}

BFS运行结果图

2.图的深度优先遍历（DFS）

思路:

准备一个记录已遍历节点的数组。
设从A开始。找到A，递归进入A并将A设为已经遍历，找一个与A相连的节点。
找到B，若B为已经遍历，递归不进入B，回溯上一个节点（此处为A）再找另一个相连节点，若无继续回溯。
此处为B为未遍历，递归进入B并将B设为已遍历，再找与B相连节点。
如3往复直到递归结束，遍历就完成了。

		void DFS(const V& x)
		{
			//std::map<V, bool> m;
			std::vector<V> m(_vertexs.size(),0);
			_DFS(x, m);
			//非连通图，递归为遍历的节点
			for (int i = 0; i < _vertexs.size(); i++)
				if (m[i] == 0)
					_DFS(_vertexs[i], m);
		}
		void _DFS(const V& x,std::vector<V>& m)
		{
			//DFS获取到值
			cout << x << " ";
			//
			m[_indexMap[x]] = 1;
			int index = _indexMap[x];
			for (int i = 0;i < _vertexs.size(); i++)
			{
				if (_matrix[index][i] != MAX_W && !m[i])
				{
					_DFS(_vertexs[i], m);
				}
			}
		}

DFS运行结果图

五.最小生成树

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

只能使用图中的边来构造最小生成树
只能使用恰好n-1条边来连接图中的n个顶点
选用的n-1条边不能构成回路

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

最小生成树，测试函数代码

void MiniTreeText()
{
	const char* str = "abcdefghi";
	AdMatrix::Graph<char, int> g(str, strlen(str));
	g.AddEdge('a', 'b', 4);
	g.AddEdge('a', 'h', 8);
	//g.AddEdge('a', 'h', 9);
	g.AddEdge('b', 'c', 8);
	g.AddEdge('b', 'h', 11);
	g.AddEdge('c', 'i', 2);
	g.AddEdge('c', 'f', 4);
	g.AddEdge('c', 'd', 7);
	g.AddEdge('d', 'f', 14);
	g.AddEdge('d', 'e', 9);
	g.AddEdge('e', 'f', 10);
	g.AddEdge('f', 'g', 2);
	g.AddEdge('g', 'h', 1);
	g.AddEdge('g', 'i', 6);
	g.AddEdge('h', 'i', 7);
	AdMatrix::Graph<char, int> kminTree;
	cout << "Kruskal:" << g.Kruskal(kminTree) << endl;
	kminTree.print();
	cout << "Prim start" << endl;
	AdMatrix::Graph<char, int> pminTree;
	cout << "Prim:" << g.Prim(pminTree, 'a') << endl;
	pminTree.print();

	//测试其他点开始的Prim情况
	//for (int i = 0; i < strlen(str); i++)
	//{
	//	AdMatrix::Graph<char, int> pminTree2;
	//	cout << "Prim:" << g.Prim(pminTree2, str[i]) << endl;
	//}
}

1.Kruskal算法

思路：

Kruskal算法使用整体贪心策略，从整体选出最小且不构环的边。
首先准备一个优先级队列将所有边入队列，一个顶点数的并查集防止构成环，一个图保存最小生成树。
随后依次将优先级队列里的边拿出，使用并查集查看边的两个顶点是否在同一集合，以此判断边是否构成环。
若判断边不构成环，则添加进最小生成树中，当添加数量到达（顶点数-1）时完成，若未到达（顶点数-1）则此图为非连通图。
¹kruskal算法图

W Kruskal(Self& miniTree)
{
	 miniTree = *this;
	 miniTree.CleanEdge();
	 int n = _vertexs.size();
	 UnionFindSet ufs(n);
	 priority_queue<Edge,std::vector<Edge>,std::greater<Edge>> miniVer;


	 //获取到每一条边，并使用优先级队列将其按权值排序
	 for(int i = 0;i < n;i++)
	 {
		 for (int j = 0; j < n; j++)
		 {
			 if (_matrix[i][j] != MAX_W)
			 {
				 Edge e(i, j, _matrix[i][j]);
				 miniVer.push(e);
			 }
		 }
	 }

	 //选边构成最小生成树
	 int k = 0;
	 W total = W();
	 while (!miniVer.empty())
	 {
		 Edge e = miniVer.top();
		 miniVer.pop();
		 //使用并查集防止构成环
		 if (!ufs.InSet(e._srci, e._dsti))
		 {
			 miniTree._AddEdge(e._srci, e._dsti, e._w);
			 ufs.Union(e._srci, e._dsti);
			 k++;
			 total += e._w;
			 //选边打印
			 cout << e._srci << ":" << _vertexs[e._srci] << "->" << e._dsti << ":" << _vertexs[e._dsti] << endl;	
		 }
		
	 }
	 非连通图
	 if (k < n - 1) {
		 return W();
	 }

	 return total;
}

Kruskal算法运行结果图图

2.Prim算法

思路：

Prim使用局部贪心的策略，将一个图分为两个部分。
根据下面图片颜色设为黑图和白图，黑图只有一个刚开始选取的开始顶点，其余顶点都为白图。
随后每次选取一条连接黑图白图的最小边构成最小生成树。
准备一个黑图bool数组对所有顶点进行hash映射其是否在黑图,白图同理。
准备一个优先级队列，将使黑白图相连的边入队列。
依次取出队列头的边，判断其是否为黑白图相连，否则会构环舍弃，是则写入最小生成树，直至边取到（总节点数-1）或队列为空，Prim算法结束。若边不为（总结点数-1）此图为非连通图。
²Prim算法图

W Prim(Self& miniTree,const V& srcv)
{
	miniTree = *this;
	miniTree.CleanEdge();
	int n = _vertexs.size();
	std::vector<int> y(n, true);
	int srci = GetVertexIndex(srcv);
	y[srci] = false;
	priority_queue<Edge, std::vector<Edge>, std::greater<Edge>> miniVer;

	//从srcv节点开始，将带srcv节点的边入队列
	for (int i = 0;i < n; i++)
	{
		if (_matrix[srci][i] != MAX_W && y[i])
		{
			Edge e(srci,i,_matrix[srci][i]);
			miniVer.push(e);
		}
	}

	int size = 0;
	W totalW = W();
	while (!miniVer.empty())
	{
		if (size == n - 1)
			break;

		//优先级队列找出最小的边
		Edge et = miniVer.top();
		miniVer.pop();
		//判断是否构成环，不构成就将边加进最小生成树中
		if (y[et._dsti])
		{
			miniTree._AddEdge(et._srci,et._dsti,et._w);
			size++;
			totalW += et._w;
			//标记节点为已选
			y[et._dsti] = false;
			//选边打印
			cout << et._srci << ":" << _vertexs[et._srci] << "->" << et._dsti << ":" << _vertexs[et._dsti] << endl;
			//将含有刚选的节点的边入队列
			for (int i = 0; i < n; i++)
			{
				//含有已选节点的边不选
				if (_matrix[et._dsti][i] != MAX_W && y[i])
				{
					miniVer.push(Edge(et._dsti, i, _matrix[et._dsti][i]));
				}
			}
		}
	}
	if (totalW < n - 1)return W();

	return totalW;
}

Prim算法运行结果图

六.最短路径

打印最短路径代码：

void PrintShortPath(const V& src,const std::vector<W>& dist,const std::vector<int>& pPath)
{
	int srci = GetVertexIndex(src);
	int n = _vertexs.size();

	for (int i = 0; i < n; i++)
	{
		std::vector<V> shortPath;
		if (i != srci)
		{
			int parent = i;
			while (parent != srci)
			{
				shortPath.push_back(_vertexs[parent]);
				parent = pPath[parent];
			}
			shortPath.push_back(_vertexs[srci]);
							reverse(shortPath.begin(), shortPath.end());

			for (auto v : shortPath)
			{
				cout << v << "->";
			}
			cout << dist[i] << endl;
		}

	}
}

1.Dijkstra算法（单源最短路径）

思路：

目的：选择一个起始节点，找到其他节点的最短路径。
开始前准备一个存储开始节点srci到下标位置目标节点最短路程的数组dist（开始时只有初始节点为0，其余为INT_MAX），一个存储到下标位置节点最短路径中的上一节点下标的数组pPath(开始时只有初始节点的值为自己下标），一个存储已找到最短路径的节点的哈希数组S（开始时节点全不在）。
首先找dist数组中不为INT_MAX且节点未被pPath标记中路径最短的节点，将找到的节点标记为已找到最短路径节点。
将3中找到的节点u进行松弛算法，即将与u相连且并未被pPath标记的节点对应下标的dist数组更新，若dist数组改变将更新节点对应pPath下标父节点更新为u下标。
重复上面3，4操作直至节点全被S标记完成。

³Dijkstra算法图

		void Dijkstra(const V& src,std::vector<W>& dist,std::vector<int>& pPath)
		{
			int srci = GetVertexIndex(src);
			int n = _vertexs.size();

			dist.resize(n,MAX_W);
			pPath.resize(n, -1);
			dist[srci] = W();
			pPath[srci] = srci;

			//节点是否已经更新完成
			std::vector<bool> S(n,false);

			for(int j = 0;j < n;j++)
			{
				int u = -1;
				int minW = MAX_W;
				for (int i = 0; i < n; i++)
				{
					if (S[i] == false && dist[i] < minW)
					{
						u = i;
						minW = dist[i];
					}
				}
				//将节点设为已求到最短路径
				S[u] = true;
				//松弛算法，将与u节点相连节点vi路径求出,又因u与srci相连,顺带求出srci到vi的路径。
				for (int i = 0;i < n;i++)
				{
					if (S[i] == false && _matrix[u][i] != MAX_W 
						&& dist[u] + _matrix[u][i] < dist[i])
					{
						dist[i] = dist[u] + _matrix[u][i];
						pPath[i] = u;
					}
				}

			}
			
		}

Dijkstra算法运行结果图

2.Bellman-Ford算法（负权图单源最短路径）

思路：

准备一个存储最短路程的数组dist，一个存储到一个节点最短路径的父节点坐标数组pPath。
从开始节点起，更新与其相连节点的最短路径，更新完每一个节点结束。
重复步骤2节点减一次，完成。

⁴Bellman-Ford算法图

		bool BellmanFord(const V& src,std::vector<W>& dist,std::vector<int>& pPath)
		{
			int srci = GetVertexIndex(src);
			int n = _vertexs.size();
			dist.resize(n, MAX_W);
			pPath.resize(n, -1);
			dist[srci] = W();
			pPath[srci] = srci;

			for (int k = 0;k < n - 1;k++)
			{
				bool exchange = false;
				//如果数组没有发生改变可以直接跳出循环
				for (int i = 0; i < n; i++)
				{
					for (int j = 0; j < n; j++)
					{
						if (_matrix[i][j] != MAX_W
							&& dist[i] + _matrix[i][j] < dist[j])
						{
							dist[j] = dist[i] + _matrix[i][j];
							pPath[j] = i;
							exchange = true;
						}
					}
				}
				if (!exchange) break;
			}
			//判断有无带负权值成环
			for (int i = 0; i < n; i++)
			{
				for (int j = 0; j < n; j++)
				{
					if (_matrix[i][j] != MAX_W
						&& dist[i] + _matrix[i][j] < dist[j])
					{
							cout << "有负权环" << endl;
							return false;
					}
				}
			}

			return true;
		}

测试代码

void BellmanFordText()
{
	const char* str = "syztx";
	AdMatrix::Graph<char, int, INT_MAX, true> g(str, strlen(str));
	g.AddEdge('s', 't', 6);
	g.AddEdge('s', 'y', 7);
	g.AddEdge('y', 'z', 9);
	g.AddEdge('y', 'x', -3);
	g.AddEdge('z', 's', 2);
	g.AddEdge('z', 'x', 7);
	g.AddEdge('t', 'x', 5);
	g.AddEdge('t', 'y', 8);
	g.AddEdge('t', 'z', -4);
	g.AddEdge('x', 't', -2);
	vector<int> dist;
	vector<int> parentPath;
	if (g.BellmanFord('s', dist, parentPath))
	{
		g.PrintShortPath('s', dist, parentPath);
	}
	else
	{
		cout << "存在负权回路" << endl;
	}


	// 微调图结构，带有负权回路的测试
	//const char* str = "syztx";
	//AdMatrix::Graph<char, int, INT_MAX, true> g(str, strlen(str));
	//g.AddEdge('s', 't', 6);
	//g.AddEdge('s', 'y', 7);
	//g.AddEdge('y', 'x', -3);
	//g.AddEdge('y', 'z', 9);
	//g.AddEdge('y', 'x', -3);
	//g.AddEdge('y', 's', 1); // 新增
	//g.AddEdge('z', 's', 2);
	//g.AddEdge('z', 'x', 7);
	//g.AddEdge('t', 'x', 5);
	//g.AddEdge('t', 'y', -8); // 更改
	//g.AddEdge('t', 'z', -4);
	//g.AddEdge('x', 't', -2);
	//vector<int> dist;
	//vector<int> parentPath;
	//if (g.BellmanFord('s', dist, parentPath))
	//{
	// g.PrintShortPath('s', dist, parentPath);
	//}
	//else
	//{
	// cout << "存在负权回路" << endl;
	//}
}

Bellman-Ford算法结果图
Bellman-Ford算法结果图（有负权环）

3.Floyd-Warshall算法（多源最短路径）

思路：

准备一个二维数组dist存储一个节点到另一节点的最短路径，一个存储i->j路径中j节点的上一个节点的下标的二维数组pPath。
遍历每一个节点做中转节点k，再遍历每一个节点若与k相连且比i->j更短则更新i->k最短路径和对应的pPath。

⁵Floyd-Warshall算法图

 		void FloydWarshall(std::vector<std::vector<W>>& vvDist,std::vector<std::vector<int>>& vvParentPath)
		{
			size_t n = _vertexs.size();
			vvDist.resize(n);
			vvParentPath.resize(n);

			//初始化
			for (size_t i = 0; i < n; ++i)
			{
				vvDist[i].resize(n, MAX_W);
				vvParentPath[i].resize(n, -1);
			}

			// 将直接相连的路径初始化
			for (size_t i = 0; i < n; i++)
			{
				for (size_t j = 0; j < n; j++)
				{
					if (_matrix[i][j] != MAX_W)
					{
						vvDist[i][j] = _matrix[i][j];
						vvParentPath[i][j] = i;
					}
					else {
						vvParentPath[i][j] = -1;
					}
					if (i == j)
					{
						vvDist[i][j] = 0;
						vvParentPath[i][j] = -1;
					}
				}
			}

			//依次用k节点作为中转节点求最短路径
			for (size_t k = 0; k < n; k++)
			{
				for (size_t i = 0; i < n; i++)
				{
					for (size_t j = 0; j < n; j++)
					{
						//i->k + k->j < i->j 更新
						if (vvDist[i][k] != MAX_W
							&& vvDist[k][j] != MAX_W
							&& vvDist[i][k] + vvDist[k][j] < vvDist[i][j])
						{
							vvDist[i][j] = vvDist[i][k] + vvDist[k][j];
							vvParentPath[i][j] = vvParentPath[k][j];
						}
					}
				}
			}
		}