图的基本概念和图的存储结构
这里存储结构采用邻接矩阵的方式保存边之间的关系。

这里学习图的两种遍历方式

1.图的遍历

广度优先遍历BFS

广度优先队列：以某个顶点为起点，一层一层进行遍历。需要借助队列

具体遍历方式与二叉树的层序遍历方式类似，不同的是要通过标记的方式防止节点的重复遍历。

namespace matrix {
	//邻接矩阵保存边关系
	template<class v, class w, w max_w = INT_MAX, bool Direction = false>
	class Graph {
	private:
		std::vector<v>_vertexs;//顶点集合
		std::map<v, int>_indexMap;//顶点与下标的映射
		std::vector<std::vector<w>>_matrix;//邻接矩阵
		//获取顶点下标
		size_t GetPointIndex(const v& point) {
			auto ptr = _indexMap.find(point);
			if (ptr != _indexMap.end()) {
				return ptr->second;
			}
			else {
				throw std::invalid_argument("顶点不存在");
				return -1;
			}
		}
	public:
		//图的创建
		Graph(std::vector<v>& points) {
			_vertexs.resize(points.size());
			for (size_t i = 0; i < points.size(); i++) {
				_vertexs[i] = points[i];
				_indexMap[points[i]] = i;
			}

			_matrix.resize(points.size());
			//邻接矩阵
			for (int i = 0; i < _matrix.size(); i++) {
				_matrix[i].resize(points.size(), max_w);
			}
		}

		//添加边关系，输入两个点，以及这两个点连线边的权值。
		void AddEdge(const v& src, const v& det, const w& weight) {
			size_t posSrc = GetPointIndex(src);
			size_t posDet = GetPointIndex(det);
			//区分有向图与无向图
			_matrix[posSrc][posDet] = weight;
			if (Direction == false) {
				//无向图，添加两条边关系
				_matrix[posDet][posSrc] = weight;
			}
		}

		void BFS(const v& src) {//传入起点
			size_t srcPos = GetPointIndex(src);
			std::queue<size_t>q;
			q.push(srcPos);
			//标记数组
			std::vector<bool>visited(_vertexs.size(), false);
			visited[srcPos] = true;//入队列标记
			int leveSize = 1;//每层节点个数
			int leve = 1;//层数
			while (!q.empty()) {
				for (int i = 0; i < leveSize; i++) {
					int front = q.front();
					std::cout << front << ":" << _vertexs[front] << " ";
					q.pop();
					//这个节点周围的节点入队
					for (size_t i = 0; i < _vertexs.size(); i++) {
						if (_matrix[front][i] != max_w) {
							//入队列时标记已经访问
							if (visited[i] == false) {
								q.push(i);
								visited[i] = true;
							}
						}
					}
				}
				leveSize = q.size();
				std::cout << "第" << leve++ << "层" << std::endl;
			}
			std::cout << std::endl;
		}
	};
}

#include"Graph.h"

using namespace std;

void TestGraph() {
	vector<char>points = { 'A','B','C','D' };
	matrix::Graph<char, int, INT_MAX, true>graph(points);
	graph.AddEdge('A', 'B', 1);
	graph.AddEdge('A', 'D', 4);
	graph.AddEdge('B', 'D', 2);
	graph.AddEdge('B', 'C', 9);
	graph.AddEdge('C', 'D', 8);
	graph.AddEdge('C', 'B', 5);
	graph.AddEdge('C', 'A', 3);
	graph.AddEdge('D', 'C', 6);
	graph.BFS('A');
}
int main() {
	TestGraph();
}

深度优先遍历DFS

深度优先遍历时，没遍历一个节点后，将这个节点标记已访问，防止重复访问。

namespace matrix {
	//邻接矩阵保存边关系
	template<class v, class w, w max_w = INT_MAX, bool Direction = false>
	class Graph {
	private:
		std::vector<v>_vertexs;//顶点集合
		std::map<v, int>_indexMap;//顶点与下标的映射
		std::vector<std::vector<w>>_matrix;//邻接矩阵
		//获取顶点下标
		size_t GetPointIndex(const v& point) {
			auto ptr = _indexMap.find(point);
			if (ptr != _indexMap.end()) {
				return ptr->second;
			}
			else {
				throw std::invalid_argument("顶点不存在");
				return -1;
			}
		}
	public:
		//图的创建
		Graph(std::vector<v>& points) {
			_vertexs.resize(points.size());
			for (size_t i = 0; i < points.size(); i++) {
				_vertexs[i] = points[i];
				_indexMap[points[i]] = i;
			}

			_matrix.resize(points.size());
			//邻接矩阵
			for (int i = 0; i < _matrix.size(); i++) {
				_matrix[i].resize(points.size(), max_w);
			}
		}

		//添加边关系，输入两个点，以及这两个点连线边的权值。
		void AddEdge(const v& src, const v& det, const w& weight) {
			size_t posSrc = GetPointIndex(src);
			size_t posDet = GetPointIndex(det);
			//区分有向图与无向图
			_matrix[posSrc][posDet] = weight;
			if (Direction == false) {
				//无向图，添加两条边关系
				_matrix[posDet][posSrc] = weight;
			}
		}
	private:
		void _DFS(size_t srcPos, std::vector<bool>& visited) {
			std::cout << srcPos << ":" << _vertexs[srcPos] << " ";
			visited[srcPos] = true;
			for (size_t i = 0; i < _vertexs.size(); i++) {
				if (_matrix[srcPos][i] != max_w && visited[i] == false) {
					_DFS(i, visited);
				}
			}
		}
	public:

		//深度优先遍历
		void DFS(const v& src) {
			size_t posSrc = GetPointIndex(src);
			std::vector<bool>visited(_vertexs.size(), false);
			_DFS(posSrc, visited);
			std::cout << std::endl;
		}
	};
}

#include"Graph.h"

using namespace std;

void TestGraph() {
	vector<char>points = { 'A','B','C','D' };
	matrix::Graph<char, int, INT_MAX, true>graph(points);
	graph.AddEdge('A', 'B', 1);
	graph.AddEdge('A', 'D', 4);
	graph.AddEdge('B', 'D', 2);
	graph.AddEdge('B', 'C', 9);
	graph.AddEdge('C', 'D', 8);
	graph.AddEdge('C', 'B', 5);
	graph.AddEdge('C', 'A', 3);
	graph.AddEdge('D', 'C', 6);
	graph.DFS('C');
}
int main() {
	TestGraph();
}

注意：
如果图是连通图，则上述的遍历方式可以将图全部遍历完毕。

如果不是连通图，最后看标记数组是否全部已经被标记。如果还有点没有标记，则说明这个图不是连通图。此时更改点继续遍历。