利用深度优先遍历求解用邻接矩阵表示的图中任意两个节点的所有路径

最近科研中需要用到求解图中任意两个姐节点间的所有路径，用到的是图的深度优先遍历及递归的使用，记录在此。

一、图的表示方式——邻接矩阵

 

我们知道图有两种表示方式，一种是邻接矩阵，一种是邻接表。我使用的是较为容易理解的邻接矩阵，且图为无向无权图，有向有权图的思想和无向无权图类似，在此不赘述。

 用邻接矩阵表示无向无权图，即用一个“顶点数×顶点数”的方阵表示节点之间的连接关系，如果两个节点之间相连，则矩阵中对应的行列值为true，否则为false。如下图中的图（节点中的数字代表节点的ID）：

对应的邻接矩阵为：

可以发现无向图始终是一个对称矩阵。

二、图的深度优先遍历

假设初始状态是图中所有顶点均未被访问，则从某个顶点v出发，首先访问该顶点，然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和v有路径相通的顶点都被访问到。 若此时尚有其他顶点未被访问到，则另选一个未被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。

显然，深度优先搜索是一个递归的过程。

深度优先遍历特点是，选定一个出发点后进行遍历，能前进则前进，若不能前进，回退一步再前进，或再回退一步后继续前进。依此重复，直到所有与选定点相通的所有顶点都被遍历。

如上图中的图，如果从节点0开始访问，则深度优先遍历的顺序为：

1.访问节点0

2.访问节点1

3.访问节点2

4.访问节点3

5.访问节点5

三、利用深度 优先遍历求解两个节点之间的所有路径

利用图的深度优先遍历，求解两个节点之间的所有路径，其实只需要稍微修改一下图的深度优先遍历代码即可，为了保存节点的访问状态，我们需要开辟一个顶点数大小的一维数组。其次，为了保存路径，需要用一个栈来记录寻路过程中经过的节点。

算法的步骤为：

1. 输入要寻路的起点和终点
2. 从起点开始，进行图的深度优先遍历
3. 将当前保存节点访问状态的标志数组的值设置为1，将当前节点入栈
4. 当遍历的节点为终点时，说明找到一条路径，将保存节点访问状态的标志数组中栈顶节点的值设置为0（未访问），弹出栈顶元素。否则将当前节点作为起点，继续递归进行图的深度优先遍历
5. 如果当前节点没有连接的未访问的节点时，说明这个从这个节点出发再没有联通的路径了，此时将保存节点访问状态的标志数组中栈顶节点的值设置为0（未访问），弹出栈顶元素

四、代码实现

定义一个MyGraph类，用来存储图。具体的头文件如下：

#include <vector>
class MyGraph
{
protected:
	int vertexNum;//顶点数量
	bool** matrix;//邻接矩阵
	bool* visitedFlag;//顶点是否访问过的标记
	std::vector<int> pathStack;//记录路径的栈
public:
	MyGraph(int VertexNum);
	MyGraph();
	void printMatrix();//输出邻接矩阵
	void updateMatrix(int row,int column);//更新row行column列的邻接矩阵值
	bool getMatrixValue(int row, int column);//获取邻接矩阵中对应行列号的值
	void getPathofTwoNode(int startNode,int endNode);//计算两个节点之间的所有路径
	void findPath(int startNode, int endNode);
	~MyGraph();
};

其中，matrix是一个二维数组指针，用来存储邻接矩阵，然后visitendFlag是一个一维数组，用来标记顶点是否访问过，pathStack是一个用vector表示的栈，用来记录路径中的节点。findPath是一个递归函数，在getPathofTwoNode中调用（原因是寻路的过程中首先要将起点入栈，这个操作不能放在递归函数中）。

然后cpp文件中的内容如下：
 

#include "MyGraph.h"
#include <iostream>
using namespace std;

MyGraph::MyGraph(int VertexNum)
{
	this->vertexNum = VertexNum;
	//开辟访问标记数组
	this->visitedFlag = new bool[vertexNum];
	//开辟邻接矩阵
	this->matrix = new bool*[vertexNum];
	for (int i=0;i<vertexNum;i++)
	{
		this->visitedFlag[i] = false;
		this->matrix[i] = new bool[vertexNum];
		//将所有数组元素全部初始化为0
		for(int j=0;j<vertexNum;j++)
			this->matrix[i][j] = 0;
	}
}

/**
 * 无参数构造函数，通过createTestData函数来构造一个邻接矩阵测试数据
 * 方便其他算法的测试
 */
MyGraph::MyGraph()
{
	this->vertexNum = 5;
	//开辟访问标记数组
	this->visitedFlag = new bool[vertexNum];
	//开辟邻接矩阵
	this->matrix = new bool*[vertexNum];
	for (int i = 0; i<vertexNum; i++)
	{
		this->matrix[i] = new bool[vertexNum];
		this->visitedFlag[i] = false;
		//将所有数组元素全部初始化为0
		for (int j = 0; j<vertexNum; j++)
			this->matrix[i][j] = 0;
	}
	//初始化邻接矩阵
	bool initMatrix[5][5] = {
		{0,1,1,0,1},
		{1,0,1,0,0},
		{1,1,0,1,1},
		{0,0,1,0,0},
		{1,0,1,0,0}};
	//赋值
	for (int i = 0; i < vertexNum; i++)
		for (int j = 0; j < vertexNum; j++)
			this->matrix[i][j] = initMatrix[i][j];
	printMatrix();
}


MyGraph::~MyGraph()
{
	for(int i=0;i<vertexNum;i++)
		delete[] matrix[i];
	delete matrix;
	delete[]visitedFlag;
}

/**
 * 输出邻接矩阵
 */
void MyGraph::printMatrix()
{
	for (int i=0;i<vertexNum;i++)
	{
		for (int j = 0; j < vertexNum; j++)
			cout << matrix[i][j]<<"  ";
		cout << endl;
	}
}

/**
 * 更新row行column列的邻接矩阵值
 */
void MyGraph::updateMatrix(int row, int column)
{
	//由于是无向图，故更新后的矩阵值是一个对称矩阵
	matrix[row][column] = true;
	matrix[column][row] = true;
}

/**
 * 获取row行column列的邻接矩阵的值
 */
bool MyGraph::getMatrixValue(int row, int column)
{
	return this->matrix[row][column];
}

/**
 * 计算两个节点之间的所有路径
 */
void MyGraph::getPathofTwoNode(int startNode, int endNode)
{
	//利用深度优先遍历的方式来计算两个节点之间的所有路径
	visitedFlag[startNode] = true;
	pathStack.push_back(startNode);
	findPath(startNode, endNode);
}

void MyGraph::findPath(int startNode, int endNode)
{
	if (startNode == endNode)
	{
		//找到一条路径，输出路径
		cout << "找到一条路径";
		for (int node : pathStack)
			cout << node << "  ";
		cout << endl;
		visitedFlag[*(pathStack.end()-1)] = false;
		pathStack.pop_back();
		return;
	}
	else
	{
		//找到startNode所有没有入栈的邻接点
		int unStackedNum = 0;
 		for (int i = 0; i<vertexNum; i++)
		{
			if (matrix[startNode][i] && !visitedFlag[i])
			{
				unStackedNum++;
				visitedFlag[i] = true;
				pathStack.push_back(i);
				findPath(i, endNode);
			}
		}
		visitedFlag[*(pathStack.end() - 1)] = false;
		pathStack.pop_back();
	}
}

其中，无参构造函数构造了一个图（就是文章第一张图中对应的图），用于各类算法的测试。

在main函数中调用，寻找0号节点到3号节点的所有路径：

MyGraph graph = MyGraph();
graph.getPathofTwoNode(0, 3);

输出结果为：

可以看到输出结果正确。