图的实现及其深度优先、广度优先遍历

图

图的概念我就不赘述了传送门讲的比我清楚
代码也很简单

int visited[10] = {
      0 };//这个是为了之后访问时候用的，存储访问信息容器
class MGraph {
     
private:
	int vertex[10];
	int arc[10][10] = {
      0 };
	int vertexnum, arcnum;
public:
	MGraph(int a[], int n, int e);
	~MGraph() {
     };
	void DFSTraverse(int v);
	void BFSTraverse(int v);
};

其构造函数还是要说一下的
用伪代码来解释：
获取顶点个数、边的条数
获取存储在数组里面的数据信息
根据边的俩顶点，用二维数组存储顶点之间的路径信息（1代表有路径联通，0代表没有）
代码：

MGraph::MGraph(int a[], int n, int e) {
     
	vertexnum = n;
	arcnum = e;
	for (int i = 0; i < vertexnum; i++) {
     
		vertex[i] = a[i];
	}
	for (int i = 0; i < vertexnum; i++) {
     
		for (int j = 0; j < vertexnum; j++) {
     
			arc[i][j] = 0;
		}
	}
	int i, j;
	for (int k = 0; k < arcnum; k++) {
     
		cout << "请输入一条边的两个顶点" << endl;
		cin >> i >> j;
		arc[i][j] = 1;
		arc[j][i] = 1;
		cout << "顶点为" << i << j << "的边已录入" << endl;
	}
}

演示图是测试图是这样的

深度优先

顾名思义，一条路走到黑，不撞南墙不回头
比如上图，从0开始，可以遍历1 → 2 → 3 → 4
到了4就不能再有相邻顶点了，所以回到0的位置，在看看走2那条路，走过了！
继续回到0，再走下5那条路，5周边的0 和 3都遍历过了，结束
代码：

void MGraph::DFSTraverse(int v) {
     
	cout << vertex[v] ;
	visited[v] = 1;
	for (int j = 0; j < vertexnum; j++) {
     
		if (arc[v][j] == 1 && visited[j] == 0) {
     
			DFSTraverse(j);
		}
	}
}

这是递归的方式，每次都是在新的顶点基础上找周边的结点进行遍历

广度优先

那就是先把自己周边能找的（路径为1）的找遍了，再找路径为2的
这就要求我们找到相邻的一个顶点后自身还不能走，一定要遍历完才能退出来
很容易想到队列
把自己周边路径为1的顶点都遍历了（入队了）自己才能出来，然后继续在队伍中找下一个搜寻未遍历的相邻元素
代码：

void MGraph::BFSTraverse(int v) {
     
	for (int i = 0; i < 10; i++) {
     
		visited[i] = 0;
	}//重置为0
	int queue[10] = {
      0 };
	int front = -1, rear = -1;
	queue[++rear] = v;
	visited[v] = 1;
	cout << vertex[v];
	while (front != rear) {
     
		v = queue[++front];
		for (int j = 0; j < vertexnum; j++) {
     
			if (arc[v][j] == 1 && visited[j] == 0) {
     
				visited[j] = 1;
				queue[++rear] = j;
				cout << vertex[j] ;
			}
		}
	}
}

具体测试

主函数：

int main() {
     
	int a[6] = {
      0,1,2,3,4,5 };
	MGraph m(a, 6, 8);
	cout << "0为起点深度优先遍历";
	m.DFSTraverse(0);
	cout << endl;
	cout << "0为起点广度优先遍历";
	m.BFSTraverse(0);
}

测试数据如上图

其实具体就是这个啦

结果

符合预期