数据结构例题代码及其讲解-图

01 图的邻接矩阵存储结构定义。

顶点表、边（二维数组）、顶点数量和边的数量

typedef struct MGraph {
    
    
	char Vex[MaxSize];//顶点(vertex)中数据
	int Edge[MaxSize][MaxSize];//边
	int vexnum, arcnum;//顶点数量和边的数量
}MGraph;

图中涉及到.和->的区别。

弧与边：弧:有向图中连接两个节点的媒介通常叫做“弧”。边:无向图中连接两个节点的媒介通常叫做“边”。而arc表示弧的意思，希望可以对大家记录这几个单词有所帮助。

02 图的邻接表存储结构定义。

//边表结点
typedef struct ArcNode {
    
    
	int adjvex;//边指向顶点的存储位置
	struct ArcNode* nextarc;//指向下一个边表结点的指针域
}ArcNode;
//顶点结点
typedef struct VNode {
    
    
	char data;//顶点中数据
	ArcNode* firstarc;//指向第一个边表结点的指针域
}VNode;
//图
typedef struct AGraph {
    
    
	VNode adjlist[MaxSize];//邻接表
	int vexnum, arcnum;//顶点数量和边的数量
}AGraph;

用邻接表存储图，需要两部分，顶点和边，这里定义了两种结点，

顶点结点：顶点结点用来存放顶点，包括数据域和指针域，其指针域用来指向这个顶点的第一条边

边表结点：边表结点用来表示边之间的关系，也包括数据域和指针域，指针域指向该顶点结点指向边。

顶点结点的指针域是ArcNode类型，也就是边表结点类型，其指向第一个边表结点。

图中定义的是顶点结点类型的数组（数组中的每个元素是顶点结点类型）。

参数定义说明：定义函数传参时，MGraph G是把邻接矩阵表示的图直接传进去了，而AGraph G是直接把邻接表表示的图传进去，但是这种情况比较少见，且主流的参考资料中，在邻接表存储的图中，使用的是AGraph* G，即传进去一个指针，这个指针指向这个图。用指针的方式，则取结构体中的内容时候，需要用->。

void Func(AGraph* G) {
    
    
	int a = G->vexnum;//a获取图的顶点数量
	int b = G->arcnum;//b获取图的边的数量
	printf("%c", G->adjlist[0].data);//打印第一个顶点结点的数据
	ArcNode* p;//定义一个ArcNode类型的p指针；
	p = G->adjlist[0].firstarc;//p初始时指向图的第一个顶点结点的指针域，也就是边表结点
	printf("%c", G->adjlist[p->adjvex].data);//通过p指针指向的边表结点的数据域，打印顶点结点
}

上述代码是图的部分操作代码，这里尤其要注意用**.还是->**来表示结构体中内容。
在这里插入图片描述

03 写出从图的邻接表表示转换成邻接矩阵表示的算法。

邻接表表示的图有邻接表，顶点数量变量和边数量变量，邻接矩阵表示的图有顶点表、边（二维数组）、顶点数量变量和边的数量变量，要将邻接表转换成邻接矩阵，对于顶点数量和边数量，直接复制过来即可，对于如何填充邻接矩阵的顶点表和边（二维数组），需要遍历；
这里按行遍历，将邻接表中的顶点信息和边的信息复制过来，在此之前需要对==邻接矩阵初始化==一下，二维数组初始化可以使用两个for循环；
遍历需要遍历指针，是边表结点(ArcNode)类型的遍历指针，按行遍历，遍历四行（也就是顶点结点的个数）。

void Func(MGraph& G1, AGraph* G2) {
    
    //MGraph表示邻接矩阵，AGraph表示邻接表
	G1.vexnum = G2->vexnum;//给图的顶点数量赋值
	G1.arcnum = G2->arcnum;//给图的边数量赋值
    //初始化邻接矩阵
	for (int i = 0; i < G2->vexnum; i++)
		for (int j = 0; j < G2->vexnum; j++)
			G1.Edge[i][j] = 0;
	ArcNode* p;//定义遍历指针
	for (int i = 0; i < G2->vexnum; i++) {
    
    
        //先复制到邻接矩阵的顶点表中
		G1.Vex[i] = G2->adjlist[i].data;//将顶点数据值存储在 Vex 数组中
        //然后处理边，也就是填充二维数组
		p = G2->adjlist[i].firstarc;//指针 p 指向顶点 i 的第一个边表结点
		while (p != NULL) {
    
    //遍历顶点 i 的所有边表结点
			G1.Edge[i][p->adjvex] = 1;//将邻接矩阵中边对应位置改为 1
			p = p->nextarc;//指针 p 继续向后遍历
		}
	}
}

04 写出从图的邻接矩阵表示转换成邻接表表示的算法。

邻接矩阵表示的图有顶点表、边（二维数组）、顶点数量变量和边的数量变量，邻接表表示的图有邻接表，顶点数量变量和边数量变量，要将邻接矩阵转换成邻接表，对于顶点数量和边数量，直接复制过来即可，对于如何填充邻接表，需要遍历邻接矩阵；
遍历邻接矩阵，如果值为1，说明有边，需要创建边表结点，插入到邻接表，可以采用头插法插入。
代码步骤如下：①给邻接表的顶点数量和边数量变量赋值；②填充邻接表的顶点结点；③遍历邻接矩阵（2个for循环遍历二维数组），存在边创建边表结点头插。

void Func(MGraph G1, AGraph * G2) {
    
    //MGraph表示邻接矩阵，AGraph表示邻接表
	G2->vexnum = G1.vexnum;//给图的顶点数量赋值
	G2->arcnum = G1.arcnum;//给图的边数量赋值
    //邻接表的顶点结点的填充
	for (int i = 0; i < G1.vexnum; i++) {
    
    //遍历存储顶点数据的 Vex 数组
		G2->adjlist[i].data = G1.Vex[i];//将各顶点数据赋值给邻接表的顶点结点中
		G2->adjlist[i].firstarc = NULL;//初始化顶点结点的指针域
	}
	ArcNode* p;//定义遍历指针
	for (int i = 0; i < G1.vexnum; i++) {
    
    //遍历邻接矩阵
		for (int j = 0; j < G1.vexnum; j++) {
    
    
			if (G1.Edge[i][j] != 0) {
    
    //若两顶点存在边则需建立边表结点
				p = (ArcNode*)malloc(sizeof(ArcNode));//创建边表结点
				p->adjvex = j;//为边表结点数据域赋值，注意是j不是i
                //将边表结点头插到对应位置
				p->nextarc = G2->adjlist[i].firstarc;
				G2->adjlist[i].firstarc = p;
			}
		}
	}
}

对于邻接表转邻接矩阵：

①复制边和顶点数量，②初始化邻接矩阵，③填充顶点表和填充邻接矩阵在一个for循环里操作；

对于邻接矩阵转邻接表：

①复制边和顶点数量，②填充邻接表的顶点结点，③两个for循环遍历邻接矩阵找边创建结点头插。

05 请写出以邻接矩阵方式存储图的广度优先遍历算法。

广度优先遍历又称BFS(Breath First Search)，先遍历最近的一层，没了在转到下一个结点，继续；
在邻接矩阵上看，就是先遍历指定结点这一行，有的话就依次打印，遍历完后，在去找下一个结点，这里需要考虑是否已经被遍历打印过，图这一章中经常会定义一个辅助数组visited[]，初始化时全部设为0，每次遍历一个结点，将其在visited[]中对应内容置为1，表示已经被遍历过了；
BFS函数需要传入邻接矩阵G，v表示需要从哪个结点开始进行广度优先遍历，以及遍历数组。
有些图是非连通图，需要检查是否有结点没有被遍历过，因此需要代码中第22行开始的部分。

BFS 为什么需要队列？

对于 BFS 算法，正如上面所说的，我们需要一层一层遍历所有的相邻结点。那么相邻结点之间的先后顺序如何确定？因此我们需要一个数据结构来进行存储和操作，需要使得先遍历的结点先被存储，直到当前层都被存储后，按照先后顺序，先被存储的结点也会被先取出来，继续遍历它的相邻结点。因此我们可以发现，这个需求不就是我们的队列吗，First In First Out (FIFO) 。因此对于 BFS 我们需要使用 Queue 这样的一个数据结构，来存储每一层的结点，同时**维护『先进先出 FIFO』**的顺序。

void BFS(MGraph G, int v, int visited[]) {
    
    //visited[]已经全部初始化为0了
	Queue Q;//定义辅助队列 Q
	InitQueue(Q);//初始化队列 Q
	printf("%c", G.Vex[v]);//打印该顶点数据
	visited[v] = 1;//更新遍历数组
	EnQueue(Q, v);//将遍历顶点地址入队
	while (!IsEmpty(Q)) {
    
    //队列不为空则继续循环
		DeQueue(Q, v);//出队并让 v 接收出队顶点地址
		for (int j = 0; j < G.vexnum; j++){
    
    //遍历邻接矩阵的第 v 行
			if (G.Edge[v][j] == 1 && visited[j] == 0) {
    
    //寻找有边且未被遍历过的顶点
				printf("%c", G.Vex[j]);//打印该顶点的数据
				visited[j] = 1;//更新遍历数组
				EnQueue(Q, j);//将该顶点地址入队
			}
        }
	}
}
void Func(MGraph G, int v) {
    
    
	int visited[G.vexnum];//定义遍历数组
	for (int i = 0; i < G.vexnum; i++)//初始化遍历数组
		visited[i] = 0;
	BFS(G, v, visited);//从顶点 v 开始进行广度优先遍历
	for (int i = 0; i < G.vexnum; i++)//检查图 G 是否有未被遍历到的顶点
		if (visited[i] == 0)//若有未被遍历到的顶点则需再次执行 BFS 算法
			BFS(G, i, visited);
}

06 请写出以邻接表方式存储图的广度优先遍历算法。

邻接矩阵中打印结点值是在顶点表中打印的，而邻接表中打印结点值需要在顶点结点中；
邻接矩阵中是遍历二维数组进行广度优先遍历，邻接表遍历边表结点进行广度优先遍历；
邻接表中需要遍历指针p才能遍历，邻接矩阵中直接for循环遍历；
遍历时，遍历指针p不为空，说明有结点相连，需要进一步判断结点是否已经被遍历过，如果没有被遍历过，打印，更新遍历数组，入队，被遍历过就不去管它，之后需要继续向后遍历。
有些图是非连通图，需要检查是否有结点没有被遍历过，因此需要代码中第25行开始的部分。
邻接表方式和邻接矩阵方式存储的图的广度优先遍历，主要区别在于邻接表要用遍历指针去遍历，而邻接矩阵可以for循环遍历。

void BFS(AGraph * G, int v, int visited[]) {
    
    
	Queue Q;//定义辅助队列 Q
	InitQueue(Q);//初始化辅助队列 Q
	printf("%c", G->adjlist[v].data);//打印地址为 v 的顶点值
	visited[v] = 1;//更新遍历数组
	EnQueue(Q, v);//将遍历顶点地址入队
	ArcNode* p;//定义遍历指针 p
	while (!IsEmpty(Q)) {
    
    //队列不为空则需继续循环
		DeQueue(Q, v);//出队并让 v 接收出队顶点地址
		p = G->adjlist[v].firstarc;//p 指针指向顶点 v 的第一个边表结点
		while (p != NULL) {
    
    //遍历顶点 v 的所有边表结点
			if (visited[p->adjvex] == 0) {
    
    //判断遍历边表结点对应顶点是否被遍历过
				printf("%c", G->adjlist[p->adjvex].data);//遍历其顶点
				visited[p->adjvex] = 1;//更新遍历数组
				EnQueue(Q, p->adjvex);//将此遍历顶点地址入队
			}
			p = p->nextarc;//遍历指针继续向后遍历
		}
	}
}
void Func(AGraph* G, int v) {
    
    
	int visited[G->vexnum];//定义遍历数组
	for (int i = 0; i < G->vexnum; i++)//初始化遍历数组
		visited[i] = 0;
	BFS(G, v, visited);//从顶点 v 开始进行广度优先遍历
	for (int i = 0; i < G->vexnum; i++)//检查图 G 是否有未被遍历到的顶点
		if (visited[i] == 0)//若有未被遍历到的顶点则需再次执行 BFS 算法
			BFS(G, i, visited);
}

07 请设计一个算法，找出邻接表方式存储的无向连通图 G 中距离顶点 v 最远的一个顶点。（所谓最远就是到达顶点 v 的路径长度最长）

考察广度优先遍历（一层一层的遍历），最后进行遍历的结点就是离最开始遍历的结点最远的结点；
连通图，不需要考虑一次广度优先遍历没有遍历完结点的情况；
在队列中，最后一个出队的结点就是最远的顶点。

int Func(AGraph * G, int v, int visited[]) {
    
    //改写 BFS，最后一个出队顶点即为所求
	for (int i = 0; i < G->vexnum; i++)//初始化遍历数组
		visited[i] = 0;
	Queue Q;//定义辅助队列 Q
	InitQueue(Q);//初始化队列 Q
	visited[v] = 1;//更新遍历数组
	EnQueue(Q, v);//令遍历顶点地址入队
	ArcNode* p;//定义遍历指针 p
	while (!IsEmpty(Q)) {
    
    //队列不为空则继续循环
		DeQueue(Q, v);//出队并让 v 接收出队顶点地址
		p = G->adjlist[v].firstarc;//遍历指针 p 指向顶点 v 的第一个边表结点
		while (p != NULL) {
    
    //遍历顶点 v 的所有边表结点
			if (visited[p->adjvex] == 0) {
    
    //若遍历边表结点对应顶点还未被遍历过
				visited[p->adjvex] = 1;//更新遍历数组
				EnQueue(Q, p->adjvex);//将该遍历顶点地址入队
			}
			p = p->nextarc;//指针 p 继续向后遍历
		}
	}
	return v;//返回最后一个出队顶点地址
}

08 请写出利用 BFS 算法求解邻接表存储的无权图中单源最短路径的算法。

单源最短路径是说，找一个顶点，其到其他顶点的最短路径，一般来说定义一个距离数组，通过广度优先遍历的一层一层的遍历，更新数组中的元素。由于可能不是连通图，因此初始化时，需要将距离设为最大。
例如：求解0号位置，也就是A结点的单源最短路径，通过广度优先遍历将B和C在距离数组中的值变成1，A结点遍历完后，遍历1号位置，也就是遍历B结点开始，剩下只有D结点没有被遍历到，因此D的距离数组中的内容应该是B在距离数组中的元素值加1，这里需要注意。
单源最短路径的累加（本题的重点是距离数组的更新融入到广度优先遍历算法中）是通过本次开始遍历的顶点在距离数组中的值+1。

void BFS_MIN_Distance(AGraph * G, int v, int visited[], int d[]) {
    
    
	for (int i = 0; i < G->vexnum; i++) {
    
    //初始化遍历数组和距离数组
		visited[i] = 0;
		d[i] = INT_MAX;
	}
	Queue Q;//定义辅助队列 Q
	InitQueue(Q);//初始化辅助队列 Q
	ArcNode* p;//定义遍历指针
	visited[v] = 1;//更新遍历数组
	d[v] = 0;//单源顶点地址为 v，该顶点到自己的距离为 0
	EnQueue(Q, v);//将该顶点地址入队
	while (!IsEmpty(Q)) {
    
    //队列不为空则继续遍历
		DeQueue(Q, v);//出队并让 v 接收出队顶点地址
		p = G->adjlist[v].firstarc;//遍历指针 p 指向顶点 v 的第一个边表结点
		while (p != NULL) {
    
    //遍历顶点 v 的所有边表结点
			if (visited[p->adjvex] == 0) {
    
    //若遍历边表结点对应的顶点还未被遍历过
				visited[p->adjvex] = 1;//更新遍历数组
				d[p->adjvex] = d[v] + 1;//更新距离数组
				EnQueue(Q, p->adjvex);//将遍历顶点地址入队
			}
			p = p->nextarc;//遍历指针继续向后遍历
		}
	}
}

09 请写出以邻接矩阵方式存储图的深度优先遍历算法。

深度优先遍历又称DFS(Depth First Search)，一直往前走，向前走不了了，往回走，看是否还有其他路可以走。
在邻接矩阵中，顶点在其所在行进行查找没有被遍历的顶点，然后跳转到该顶点所在行，依次进行下去；如果找不到没有被遍历的顶点，则返回到上一个顶点所在行，继续往后寻找没有被遍历的顶点。
这里涉及到往下递和往回归的过程，可以通过递归编写代码。
递归的案例可以看一下

在这里插入图片描述

void DFS(MGraph G, int v, int visited[]) {
    
    
	printf("%c", G.Vex[v]);//打印顶点 v 的数据
	visited[v] = 1;//更新遍历数组
	for (int j = 0; j < G.vexnum; j++) {
    
    //遍历邻接矩阵的第 v 行
		if (G.Edge[v][j] == 1 && visited[j] == 0)//寻找第一个有边且未被遍历过的顶点
			DFS(G, j, visited);//递归打印顶点 j 的数据值
	}
}
void Func(MGraph G, int v) {
    
    
	int visited[G.vexnum];//定义遍历数组
	for (int i = 0; i < G.vexnum; i++)//初始化遍历数组
		visited[i] = 0;
	DFS(G, v, visited);//从顶点 v 开始进行深度优先遍历
    //非连通图的时候需要检查没有被遍历的顶点
	for (int i = 0; i < G.vexnum; i++)//检查图 G 是否有未被遍历到的顶点
		if (visited[i] == 0)//若有未被遍历到的顶点则需再次执行 DFS 算法
			DFS(G, i, visited);
}

10 请写出以邻接表方式存储图的深度优先遍历算法。

while (p != NULL)和p = p->nextarc;相当于邻接矩阵里面的for循环遍历。

void DFS(AGraph * G, int v, int visited[]) {
    
    
	printf("%c", G->adjlist[v].data);//打印顶点 v 的数据
	visited[v] = 1;//更新遍历数组
	ArcNode* p = G->adjlist[v].firstarc;//遍历指针 p 指向顶点 v 的第一个边表结点
	while (p != NULL) {
    
    //遍历顶点 v 的所有边表结点
		if (visited[p->adjvex] == 0)//寻找其未被遍历过的边表结点
			DFS(G, p->adjvex, visited);//递归打印该顶点的数据值
		p = p->nextarc;//遍历指针继续向后遍历
	}
}
void Func(AGraph* G, int v) {
    
    
	int visited[G->vexnum];//定义遍历数组
	for (int i = 0; i < G->vexnum; i++)//初始化遍历数组
		visited[i] = 0;
	DFS(G, v, visited);//从顶点 v 开始进行深度优先遍历
	for (int i = 0; i < G->vexnum; i++)//检查图 G 是否有未被遍历到的顶点
		if (visited[i] == 0)//若有未被遍历到的顶点则需再次执行 DFS 算法
			DFS(G, i, visited);
}

11 有向图 G 以邻接表方式存储的，请设计一个算法判断图 G 中顶点 i 到顶点 j 是否存在路径。(i 和 j 不相等)

考的是图的遍历，假设从顶点i处遍历，经过一次广度优先遍历/深度优先遍历后，去看visited[]数组中顶点j是否被遍历过。

int Path_i_j(AGraph* G, int i, int j) {
    
    //此算法省略了 DFS 算法书写
	int visited[G->vexnum];//定义遍历数组
	for (int k = 0; k < G->vexnum; k++)//初始化遍历数组
		visited[k] = 0;
	DFS(G, i, visited);//从顶点 i 开始进行深度优先遍历，也可改为 BFS(G,i,visited)
	if (visited[j] == 1)//若深度优先遍历执行结束后遍历数组中顶点 j 被遍历了
		return 1;//则说明顶点 i 到顶点 j 有路径
	else//若顶点 j 未被遍历到，则说明无路径
		return 0;
}

12 请设计一个算法判断一个邻接表存储的无向图中有几个连通分量。

一开始写的BFS/DFS算法都是争对连通图的算法，如果不是连通图，需要加一个新的函数，判断是否有没有被遍历到的结点，然后重复调用BFS/DFS算法；
这里记录连通分量数量也就是改写之前我们写的，也就是看要执行几次遍历，定义一个count变量累加即可。

int Func(AGraph* G) {
    
    //此算法省略了 DFS 算法的书写
	int visited[G->vexnum];//定义遍历数组
	for (int i = 0; i < G->vexnum; i++)//初始化遍历数组
		visited[i] = 0;
	int count = 0;//定义变量 count 负责记录连通分量的个数
	for (int i = 0; i < G->vexnum; i++)//遍历辅助数组
		if (visited[i] == 0) {
    
    //若存在未被遍历的顶点则以此顶点开始执行 DFS 算法
			DFS(G, i, visited);//也可改为 BFS(G,i,visited)
			count++;//每执行一次 DFS 算法连通分量个数就加一
		}
	return count;//最后返回 count 值即为连通分量个数
}

13 试设计一个算法，判断一个邻接表存储的无向图 G 是否为一棵树。

算法思想：树的要求：①连通图；②边的数量=顶点数量-1。
BFS/DFS遍历都可以；
一次遍历后，visited[]数组若全为1，说明是连通图，G->arcnum == G->vexnum - 1
无向图中，边会计算两次从A->B和从B->A，但是这里默认边的数量是实际边的数量，没有乘以2的情况。

int IsTree(AGraph * G) {
    
    //此算法省略了 DFS 算法的书写
	int visited[G->vexnum];//定义遍历数组
	for (int i = 0; i < G->vexnum; i++)//初始化遍历数组
		visited[i] = 0;
	DFS(G, 0, visited);//遍历图 G，也可改为 BFS(G,0,visited)
	for (int i = 0; i < G->vexnum; i++)//检查图 G 是否有未被遍历到的顶点
		if (visited[i] == 0)//若有未遍历顶点，则图 G 不连通，不是树，返回 0
			return 0;
	if (G->arcnum == G->vexnum - 1)//若图 G 是连通图且满足边数等于顶点数减一
		return 1;//则图 G 是树，返回 1
	else//若图 G 是连通图但不满足边数等于顶点数减一，则不是树，返回 0
		return 0;
}

14 有一个邻接矩阵形式存储的连通图 G，试写出图 G 深度优先遍历的非递归算法。

写非递归算法，需要自己定义栈，因为递归也是调用了递归工作栈；
j == G.vexnum表示没有从上面的for循环中break，也就是说没有边或者有边但是已经被遍历过了，说明这一行没有满足条件的，因此出栈，方便后续回到上一层。

void DFS(MGraph G, int v, int visited[]) {
    
    
	for (int i = 0; i < G.vexnum; i++)//初始化遍历数组
		visited[i] = 0;
	Stack S;//定义辅助栈 S
	InitStack(S);//初始化栈 S
	printf("%c", G.Vex[v]);//打印顶点 v 的数据
	visited[v] = 1;//更新遍历数组
	Push(S, v);//将该顶点地址压入栈中
	int j;
	while (!IsEmpty(S)) {
    
    //栈不为空则需继续循环
		GetTop(S, v);//让变量 v 接收栈顶顶点地址但不出栈
		for (j = 0; j < G.vexnum; j++) {
    
    //遍历邻接矩阵的第 v 行
			if (G.Edge[v][j] == 1 && visited[j] == 0)//寻找有边且还未被遍历的顶点
				break;//找到第 v 行满足条件的顶点后，则直接跳出循环
		}
		if (j == G.vexnum)//若第 v 行没有满足条件的顶点，则出栈
			Pop(S, v);
		else {
    
    //若找到了第 v 行满足条件的顶点
			printf("%c", G.Vex[j]);//打印其数据值
			visited[j] = 1;//更新遍历数组
			Push(S, j);//将该顶点地址压入栈中
		}
	}
}

15 有一个邻接表形式存储的连通图 G，试写出图 G 深度优先遍历的非递归算法。

连通图，只需要写一个函数就行；
首先要初始化visited数组，还要自己定义且初始化栈，然后就是打印v顶点的数据且将visited数组更新，然后入栈，由于是邻接表，因此需要遍历指针而且是边表结点的遍历指针，因此这里是ArcNode* p；
深度优先遍历由于需要回到上一层，因此一般是不出栈的，而是用变量去接收栈顶元素进行判断，而在邻接表中表示的都是边，因此这里着重判断是否被遍历过p==NULL说明邻接表中一排已经遍历完了，和邻接矩阵的非递归表示【if (j == G.vexnum)，Pop(S, v);】即一行遍历完没有符合条件的，需要出栈，方便后续回到上一层。
p!=NULL，说明找到可以往下遍历的边表结点，打印，更新遍历数组，压栈下一次while循环，读栈顶，p就会从这一行的第一个边表节点开始遍历。

void DFS(AGraph * G, int v, int visited[]) {
    
    
	for (int i = 0; i < G->vexnum; i++)//初始化遍历数组
		visited[i] = 0;
	Stack S;//定义辅助栈 S
	InitStack(S);//初始化栈 S
	printf("%c", G->adjlist[v].data);//打印顶点 v 的数据
	visited[v] = 1;//更新遍历数组
	Push(S, v);//将该顶点地址值压入栈中
	ArcNode* p;//定义遍历指针 p
	while (!IsEmpty(S)) {
    
    //栈不为空则需继续循环
		GetTop(S, v);//让变量 v 接收栈顶顶点地址但不出栈
		p = G->adjlist[v].firstarc;//遍历指针 p 指向顶点 v 的第一个边表结点
		while (p != NULL && visited[p->adjvex] == 1)//寻找边表结点中未遍历的顶点
			p = p->nextarc;
		if (p == NULL)//若 p 为空顶点 v 的所有的边表结点都已处理完毕
			Pop(S, v);//顶点 v 地址出栈
		else {
    
    //若指针 p 所指边表结点对应顶点还未遍历过
			printf("%c", G->adjlist[p->adjvex].data);//打印其数据值
			visited[p->adjvex] = 1;//更新遍历数组
			Push(S, p->adjvex);//将该顶点地址压入栈中
		}
	}
}

邻接矩阵和邻接表的DFS非递归算法的第二个while循环中都需要判断是否整行都不符合往下遍历的条件。

16 假设图用邻接表表示，设计一个算法，输出从顶点 u 到顶点 v 的所有简单路径。

简单路径：没有重复结点也找到最终路径，比如A-B-E从顶点A到顶点B，简单路径A-B，非简单路径A-B-E-B；
改写**深度优先遍历+回溯**，如果找到了一条简单路径，下一步就要回退一步，试着往其他节点处走，是否能到终点；
如果一条路走带头，无路可走，往回退一步；
path[]代表路径数组，d表示路径数组的下标；
首先要将路径数组填充一下，更新遍历数组，如果找到一条路径（寻找顶点即为目标顶点），就打印路径，然后我们需要回溯，去到上一个结点，

void PrintPath(AGraph * G, int u, int v, int visited[], char path[], int d) {
    
    //d初始时为-1
	d++;//变量 d 为路径数组索引
	path[d] = G->adjlist[u].data;//从 u 开始寻找路径
	visited[u] = 1;//更新遍历数组
	if (u == v) {
    
    //若此时开始寻找顶点即为目标顶点则打印路径
		for (int i = 0; i <= d; i++)//打印路径数组中存储的路径
			printf("%c", path[i]);
		visited[u] = 0;//回溯
		return;
	}
	ArcNode* p = G->adjlist[u].firstarc;//深度优先遍历改写
	while (p != NULL) {
    
    
		if (visited[p->adjvex] == 0)
			PrintPath(G, p->adjvex, v, visited, path, d);//当前顶点开始继续寻找路径
        //上面的if判断如果成立，从顶点结点指向的边表结点开始继续递归，直到最上面的
		p = p->nextarc;
	}
	visited[u] = 0;//更新遍历数组，回溯寻找是否有其它路径
}
//主函数
void Func(AGraph* G, int u, int v) {
    
    
	int visited[G->vexnum];//定义遍历数组
	char path[G->vexnum];//定义路径数组，这里可以不初始化，因为后面是先更新path数组，然后打印。
	for (int i = 0; i < G->vexnum; i++)//初始化遍历数组
		visited[i] = 0;
	PrintPath(G, u, v, visited, path, -1);//调用函数输出两顶点的所有简单路径
}

大家可以参考下回溯法的模板

//一定要分成横纵两个方面思考回溯
void backtracking(参数) {
    
    
    if (终止条件) {
    
    
        存放结果;
        return;
    }
    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
    
    //注意i=0,i=start的区别
        处理节点;
        backtracking(路径，选择列表); // 递归  注意(i)和(i++)的区别  后面会懂
        回溯，撤销处理结果
    }
}

在这里插入图片描述

for/while循环横向遍历，递归纵向遍历，回溯不断调整结果集

17 请写出邻接表存储有向图的拓扑排序算法。

拓扑排序（不唯一）：对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边(u,v)∈E(G)，则u在线性序列中出现在v之前。
拓扑排序的步骤：①按照一定的顺序进行构造有向图，记录后个节点的入度；②从图中选择一个入度为0的顶点,输出该顶点； ③从图中删除该顶点及所有与该顶点相连的边；④重复上述两步，直至所有顶点输出。 ⑤或者当前图中不存在入度为0的顶点为止。此时可说明图中有环。
由于需要考虑到入度，可以在顶点结点处结构体定义一下，加一个入度的变量；
有环的情况，可以定义一个count计数变量
初始化好栈后，第一步找是否有入度为0的结点，有则将其入栈（栈中存放的是入度为0的结点），如果栈不为空，说明有入度为0的结点，出栈（用i去接收），打印，这里处理了，count++，然后就需要将出栈的顶点指向的所有顶点的入度减一，减到0了就要将其压栈；
最后只需要比较count和顶点数量是否相等，不相等说明有环。

结构体定义

//边表结点
typedef struct ArcNode {
    
    
	int adjvex;
	struct ArcNode* nextarc;
}ArcNode;
//顶点结点
typedef struct VNode {
    
    
	char data;
	int indegree;//顶点结点结构体增加了一个记录入度的成员
	ArcNode* firstarc;
}VNode;
typedef struct AGraph {
    
    
	VNode adjlist[MaxSize];
	int vexnum, arcnum;
}AGraph;

int Top(AGraph* G) {
    
    
	int i = 0, count = 0;//i在入栈出栈时使用，定义变量 count 记录拓扑排序顶点的个数
	ArcNode* p;//定义遍历指针 p
	Stack S;//定义栈 S
	InitStack(S);//初始化栈 S
	for (; i < G->vexnum; i++)//遍历邻接表的顶点结点
		if (G->adjlist[i].indegree == 0)//将入度为 0 的顶点压入栈中
			Push(S, i);
	while (!IsEmpty(S)) {
    
    //栈不为空则证明还有入度为 0 的顶点需要处理
		Pop(S, i);//出栈，让变量 i 接收出栈顶点地址
		printf("%c", G->adjlist[i].data);//打印出栈顶点数据值
		count++;//记录打印过的顶点个数
        //⭐将出栈的顶点指向的所有顶点的入度减一
		p = G->adjlist[i].firstarc;//遍历指针 p 指向出栈顶点的第一个边表结点
		while (p != NULL) {
    
    //遍历出栈顶点的所有边表结点
			G->adjlist[p->adjvex].indegree--;//该顶点指向的顶点入度减一
			if (G->adjlist[p->adjvex].indegree == 0)//判断入度减一后是否等于 0
				Push(S, p->adjvex);//若等于 0 则压入栈中，等待处理
			p = p->nextarc;//遍历指针继续遍历
		}
	}
	if (count == G->vexnum)//若循环结束所有顶点都已打印，则拓扑排序成功
		return 1;
	else//若循环结束打印顶点数小于顶点个数，则该图有环，拓扑排序失败
		return 0;
}

18 请设计一个算法判断一个邻接表存储的无向图中是否有环。

方法不唯一，其中一个简单易懂的方法：和之前判断无向图是否构成一棵树的思想类似①是否为连通图②边=顶点-1（也是图的一个临界条件），若边再少一条，就不是连通图了，如果再加一条边，就构成了环。如果不是连通图，边=顶点数-连通分量数，如果边>顶点数-连通分量数，说明有环，这里不存在边<顶点数-连通分量数，因为一旦边少了一条，连通分量+1，左右都减去1，又平衡了。
Func()返回的是连通分量个数

int Func(AGraph * G) {
    
    //函数功能：计算图 G 中连通分量个数
	int visited[G->vexnum];//定义遍历数组
	for (int i = 0; i < G->vexnum; i++)//初始化遍历数组
		visited[i] = 0;
	int count = 0;//定义变量 count 负责记录连通分量的个数
	for (int i = 0; i < G->vexnum; i++)//遍历辅助数组
		if (visited[i] == 0) {
    
    //若存在未被遍历的顶点则以此顶点开始执行 DFS 算法
			DFS(G, i, visited);//此算法省略了 DFS 算法的书写
			count++;//每执行一次 DFS 算法连通分量个数就加一
		}
	return count;//最后返回 count 值即为连通分量个数
}
int IsLoop(AGraph* G) {
    
    
	int n = Func(G);//定义变量 n 记录图中连通分量个数
	if (G->arcnum == G->vexnum - n)//若满足临界条件，则该无向图不存在环
		return 0;
	else//若边的数量大于临界条件，则该无向图存在环
		return 1;
}

如何判断有向图中是否有环呢--拓扑排序，拓扑排序失败，说明有环。

19 请写出构造最小生成树的 Prim 算法。

生成树，包含连通图中所有的顶点，且任意两顶点之间有且仅有一条通路（边=顶-1）
最小生成树，找出来的所有边，权值之和最小，最小生成树不是唯一的，但是最小生成树的权值之和是唯一的。
使用邻接矩阵构造图，因为邻接矩阵中存放权值比较方便；
首先要告诉程序从哪个顶点开始找边，lowcost[]数组用来存储当前最小生成树到其他各顶点的最短距离，每次最小生成树更新，lowcost[]也要更新。对于visited[]数组，先通过for循环进行初始化，对于lowcost[]数组，初始化时候，就是对应v顶点所在邻接矩阵的那一行（此时，这行就是该顶点到其他顶点的最短距离），然后更新visited[]数组，将顶点v所在的元素变成1，说明已经加入最小生成树了。然后就是重点了，就是需要找最小生成树的顶点到其他顶点最短距离的顶点，也就是找那条链接最小生成树的最短的边，因此这个循环查找的次数就是**顶点-1**次，每次查找将变量min设置为整型变量的最大值，方便后续更新其值，由于lowcost[]数组中存放的就是当前最小生成树到其他顶点的最短距离，我们遍历它，找到里面的最小值和顶点元素，如果遍历过程中找到之前没有被遍历过的顶点（没有加到最小生成树中的顶点）且其在lowcost[]数组中的距离比min还要小，因此需要更新min和顶点k的值，遍历完成后，则找到了最短距离及顶点，visited[]数组中其对应的元素置为1，最后需要更新lowcost[]数组，因为最小生成树加入了一个顶点，lowcost[]可能会发生变化。每次加入顶点后，用邻接矩阵中新加入顶点所在行与原来lowcost[]数组进行比较，如果变小了，需要更新lowcost[]数组。

void Prim(MGraph G, int v) {
    
    
	int visited[G.vexnum];//记录当前最小生成树中包含的顶点
	int lowcost[G.vexnum];//记录当前最小生成树到其它各顶点的最短距离
	for (int i = 0; i < G.vexnum; i++) {
    
    //初始化辅助数组
		visited[i] = 0;
		lowcost[i] = G.Edge[v][i];
	}
	printf("%d", G.Vex[v]);//打印当前加入最小生成树的顶点
	visited[v] = 1;//更新辅助数组
	int min, k;//定义变量 min 记录当前最小生成树到其它顶点的最小距离
	for (int i = 0; i < G.vexnum - 1; i++) {
    
    //共需找顶点个数减一条边
		min = INT_MAX;//每一次寻找前都需要初始化 min
		for (int j = 0; j < G.vexnum; j++)//遍历记录距离的数组
			if (visited[j] == 0 && lowcost[j] < min) {
    
    //寻找此时距离最小的边
				min = lowcost[j];//min 记录最小生成树到其它顶点的最小距离
				k = j;//k 记录最小权值边对应的顶点
			}
		printf("%d", G.Vex[k]);//打印当前加入最小生成树的顶点
		visited[k] = 1;//更新辅助数组
		for (int j = 0; j < G.vexnum; j++)//更新记录最小生成树到其它顶点距离的数组
			if (visited[j] == 0 && G.Edge[k][j] < lowcost[j])
				lowcost[j] = G.Edge[k][j];
	}
}

20 请写出构造最小生成树的 Kruskal 算法。

边按照权值递增的次序进行找，看是否合适（成环就不合适了）；
①构造新的结构体存储边相关的信息，包括起始顶点，结束顶点，权值；②然后进行递增排序；③使用并查集进行

typedef struct {
    
    //存储边的结构体
	int s;//记录边的起点start
	int e;//记录边的终点end
	int weight;//记录边的权值
}edge;
int Find(int S[], int x) {
    
    //在并查集 S 中查找 x 所在集合的根
	while (S[x] >= 0)
		x = S[x];
	return x;
}

邻接矩阵是对称的，只需要遍历上三角或者下三角就行。首先将邻接矩阵中的各边权值放到存放边信息的结构体中，然后对其排序

void Kruskal(MGraph G) {
    
    
	edge e[G.arcnum];//定义保存图中所有边的辅助数组
	int k = 0;//记录数组下标
	for (int i = 0; i < G.vexnum; i++)//①遍历邻接矩阵，将所有的边存储到辅助数组中
		for (int j = i + 1; j < G.vexnum; j++) {
    
    
			e[k].s = i;//边的起点
			e[k].e = j;//边的终点
			e[k].weight = G.Edge[i][j];//边的权值
			k++;//继续处理下一个数组元素
		}
    //②递增排序
	edge temp;//定义辅助变量 temp 保存待排序元素
	for (int i = 1; i < G.arcnum; i++)//直接插入排序
		if (e[i].weight < e[i - 1].weight) {
    
    
			temp = e[i];
			for (int j = i - 1; temp.weight < e[j].weight; j--)
				e[j + 1] = e[j];
			e[j + 1] = temp;
		}
    //③并查集操作
	int S[G.vexnum];//定义数组存储并查集
	int count = 0;//定义变量 count 记录符合要求边的数量
	int start, end;//定义两变量分别保存边起点和终点所在集合的根
	for (int i = 0; i < G.vexnum; i++)//初始化并查集数组
		S[i] = -1;
	for (int i = 0; i < G.arcnum; i++) {
    
    //遍历保存边的辅助数组
		start = Find(S, e[i].s);//查找边的起点所在集合的根
		end = Find(S, e[i].e);//查找边的终点所在集合的根
		if (start != end) {
    
    //若边的起点和终点在不同集合，则此条边符合要求
			S[start] = end;//将边的起点和终点合并为一个集合里
			printf("%d - %d", e[i].s, e[i].e);//打印此边
			count++;//更新计数变量
			if (count == G.vexnum - 1)//保留边的数量等于顶点数减一则任务完成
				break;
		}
	}
}

21 请写出求单源最短路径的 Dijkstra 算法。

之前求过单源最短路径，是对于无权图来说的，可以修改广度优先遍历实现，这次是对于有权图来说的。
visited[]先初始化为0，dist[]和path[]也要初始化，dist[]中先把顶点v在邻接矩阵中的那权值复制过来，并且将path[]中初始化为v；

void Dijkstra(MGraph G, int v) {
    
    
	int visited[G.vexnum];//记录各顶点是否找到最短路径，找到置为1，没找到置为0
	int dist[G.vexnum];//记录目前源点到各顶点的最短距离
	int path[G.vexnum];//记录目前源点到各顶点最短路径的前驱顶点
	for (int i = 0; i < G.vexnum; i++)//初始化辅助数组
		visited[i] = 0;
	for (int i = 0; i < G.vexnum; i++) {
    
    //初始化辅助数组
		dist[i] = G.Edge[v][i];
		path[i] = v;
	}
	visited[v] = 1;//已确定源点 v 的最短路径
	int min, k;//定义变量 min 记录目前未确定最短路径顶点中的最小距离，k对应最短路径的顶点
    //已经确定了一个顶点，只需要在确定顶点数-1个顶点就好。
	for (int i = 0; i < G.vexnum - 1; i++) {
    
    //每次循环确定一个顶点的最短路径
		min = INT_MAX;//初始化记录最小值的变量 min
		for (int j = 0; j < G.vexnum; j++) {
    
    //遍历记录距离的数组
			if (visited[j] == 0 && dist[j] < min) {
    
    
				min = dist[j];//变量 min 记录未确定最短路径顶点中的最小距离
				k = j;//变量 k 记录最小距离对应的顶点
			}
		}
		visited[k] = 1;//已确定顶点 k 的最短路径
		for (int j = 0; j < G.vexnum; j++) {
    
    //更新距离数组
			if (visited[j] == 0 && dist[k] + G.Edge[k][j] < dist[j]) {
    
    
				dist[j] = dist[k] + G.Edge[k][j];//发现更短路径则更新距离数组
				path[j] = k;//更新路径数组
			}
		}
	}
}

22 请写出求各顶点之间最短路径的 Floyd 算法。

用到了动态规划的算法思想：

void Floyd(MGraph G) {
    
    
	int i, j, k;
	int A[MaxSize][MaxSize];//定义二维数组记录两顶点间最短距离
	int path[MaxSize][MaxSize];//定义二维数组记录最短路径中转点
	for (i = 0; i < G.vexnum; i++) {
    
    //初始化两个二维数组
		for (j = 0; j < G.vexnum; j++) {
    
    
			A[i][j] = G.Edge[i][j];//根据顶点间的直连边计算初始顶点间最短距离
			path[i][j] = -1;//初始时顶点间最短路径没有中转点
		}
	}
	for (k = 0; k < G.vexnum; k++) {
    
    //变量 k 为此次循环的中转点
		for (i = 0; i < G.vexnum; i++) {
    
    //遍历两个二维数组
			for (j = 0; j < G.vexnum; j++) {
    
    
				if (A[i][k] + A[k][j] < A[i][j]) {
    
    //中转点加入是否需要更新最短距离
					A[i][j] = A[i][k] + A[k][j];//更新顶点 i 到 j 的最短距离
					path[i][j] = k;//更新顶点 i 到 j 的最短路径中转点
				}
			}
		}
	}
}
void PrintPath(int u, int v, int A[][MaxSize], int path[][MaxSize]) {
    
    //打印最短路径
	if (A[u][v] == INT_MAX)//顶点 u 到 v 没有路径
		printf("顶点%d到顶点%d没有路径", u, v);
	else if (path[u][v] == -1)//顶点 u 到 v 有直达路径
		printf(" %d - %d", u, v);
	else {
    
    //顶点 u 到 v 有中转路径
		int mid = path[u][v];//定义变量 mid 记录顶点 u 到 v 的最短路径中转点
		PrintPath(u, mid, A, path);//递归打印顶点 u 到中转点 mid 的最短路径
		PrintPath(mid, v, A, path);//递归打印中转点 mid 到顶点 v 的最短路径
	}
}