• 37.图练习（王道第6章综合练习）

    图的存储结构，可以有邻接表表示和矩阵表示两种。我们实现邻接表表示（矩阵表示用一个二维数组就可以）：

    1. #include
    2. #include
    3. #include
    4. #define maxvex 5
    5. #define ElemType char
    6.  
    7. //边表结点
    8. typedef struct edgenode{
    9. 	int adjvex;  //下标
    10. 	int weight;  //权值，可有可没有      
    11. 	struct edgenode *next;
    12. }EdgeNode;
    13.  
    14. //顶点结点
    15. typedef struct node{
    16. 	int data;
    17. 	EdgeNode *first;  //边表头指针
    18. }VertexNode,AdjList[maxvex];
    19.  
    20. //二次封装
    21. typedef struct {
    22. 	AdjList adjlist;
    23. 	int numetex, numedge;
    24. }GraAdjList;
    25.  
    26. //创建邻接表
    27. void CreateAlGraph(GraAdjList &g,int x)
    28. {  //i=0创建有向图，i=1创建无向图
    29. 	int m, n;
    30. 	EdgeNode *e = NULL;
    31. 	EdgeNode *q = NULL;
    32.     printf("请输入顶点数和边数（无向图端点相同只需录入一条边）:");
    33. 	scanf("%d %d", &g.numetex, &g.numedge);
    34.     printf("请输入顶点的信息：");
    35. 	
    36. 	//获取顶点的信息
    37. 	for (int i = 0;i < g.numetex;i++)
    38. 	{
    39.         scanf("%d", &g.adjlist[i].data);
    40.         g.adjlist[i].first = NULL;
    41. 	}
    42. 	//建立边表，链表采用头插法
    43. 	for (int k = 0; k < g.numedge; k++)
    44. 	{
    45.         printf("请输入边（Vi,Vj）的顶点下标：");
    46.         scanf("%d %d", &m, &n);
    47.         //链表结点
    48. 		if(x == 0){
    49. 			e = (EdgeNode *)malloc(sizeof(EdgeNode));
    50. 			e->adjvex = n;
    51. 			e->next = NULL;
    52. 			//头插法建链
    53. 			if (g.adjlist[m].first == NULL)
    54. 				q = g.adjlist[m].first = e;
    55. 			else
    56. 				q = q->next = e;
    57. 		}
    58. 		else{
    59. 			e = (EdgeNode *)malloc(sizeof(EdgeNode));
    60. 			e->adjvex = n;
    61. 			e->next = NULL;
    62. 			if (g.adjlist[m].first == NULL)
    63. 				q = g.adjlist[m].first = e;
    64. 			else
    65. 				q = q->next = e;
    66. 			//对无向图，一个边要在两个结点都增加
    67. 			e = (EdgeNode *)malloc(sizeof(EdgeNode));
    68. 			e->adjvex = m;
    69. 			e->next = NULL;
    70. 			if (g.adjlist[n].first == NULL)
    71. 				q = g.adjlist[n].first = e;
    72. 			else
    73. 				q = q->next = e;
    74. 		}
    75. 	}
    76. }
    77. void print(const GraAdjList &g){
    78. 	EdgeNode *p;
    79. 	for (int k = 0;k < g.numetex;k++){
    80. 		printf("顶点%d: ", k);
    81. 		for (p = g.adjlist[k].first; p;p = p->next)
    82.             if (p != NULL)
    83.                 printf("%d ", p->adjvex);
    84.         printf("\n");
    85.     }
    86. }
    87.  
    88. int main(){
    89. 	GraAdjList gralist;
    90. 	CreateAlGraph(gralist, 1);  //i=0创建有向图，i=1创建无向图
    91. 	print(gralist);
    92. 	Graphtomartix(gralist);
    93. }

    输出：

    1. 请输入顶点数和边数（无向图端点相同只需录入一条边）:3 1
    2. 请输入顶点的信息：0 1 2
    3. 请输入边（Vi,Vj）的顶点下标：0 1
    4. 顶点0: 1 
    5. 顶点1: 0 
    6. 顶点2:

    然后我们再实现图的广度优先遍历（BFS）：

    1. #include
    2. #include
    3. #include
    4. #define maxvex 10
    5. #define MAXSIZE 10
    6.  
    7. //边表结点
    8. typedef struct edgenode{
    9. 	int adjvex;  //下标
    10. 	int weight;  //权值，可有可没有      
    11. 	struct edgenode *next;
    12. }EdgeNode;
    13.  
    14. //顶点结点
    15. typedef struct node{
    16. 	int data;
    17. 	EdgeNode *first;  //边表头指针
    18. }VertexNode,AdjList[maxvex];
    19.  
    20. //二次封装
    21. typedef struct {
    22. 	AdjList adjlist;
    23. 	int numetex, numedge;
    24. }GraAdjList;
    25.  
    26. //创建邻接表
    27. void CreateAlGraph(GraAdjList &g,int x)
    28. {  //i=0创建有向图，i=1创建无向图
    29. 	int m, n;
    30. 	EdgeNode *e = NULL;
    31. 	EdgeNode *q = NULL;
    32.     printf("请输入顶点数和边数（无向图端点相同只需录入一条边）:");
    33. 	scanf("%d %d", &g.numetex, &g.numedge);
    34. 	//获取顶点的信息
    35. 	for (int i = 0;i < g.numetex;i++){
    36. 		g.adjlist[i].data = i;
    37. 		g.adjlist[i].first = NULL;
    38. 	}
    39. 	//建立边表，链表采用头插法
    40. 	for (int k = 0; k < g.numedge; k++){
    41.         printf("请输入边（Vi,Vj）的顶点下标：");
    42.         scanf("%d %d", &m, &n);
    43.         //链表结点
    44. 		if(x == 0){
    45. 			e = (EdgeNode *)malloc(sizeof(EdgeNode));
    46. 			e->adjvex = n;
    47. 			e->next = NULL;
    48. 			//头插法建链
    49. 			if (g.adjlist[m].first == NULL)
    50. 				q = g.adjlist[m].first = e;
    51. 			else
    52. 				q = q->next = e;
    53. 		}
    54. 		else{
    55. 			e = (EdgeNode *)malloc(sizeof(EdgeNode));
    56. 			e->adjvex = n;
    57. 			e->next = NULL;
    58. 			q = g.adjlist[m].first;
    59. 			g.adjlist[m].first = e;
    60. 			g.adjlist[m].first->next = q;
    61. 			//对无向图，一个边要在两个结点都增加
    62. 			e = (EdgeNode *)malloc(sizeof(EdgeNode));
    63. 			e->adjvex = m;
    64. 			e->next = NULL;
    65. 			q = g.adjlist[n].first;
    66. 			g.adjlist[n].first = e;
    67. 			g.adjlist[n].first->next = q;
    68. 		}
    69. 	}
    70. }
    71.  
    72. typedef struct Queue{
    73. 	int data[MAXSIZE];
    74.     int front, rear;  //头尾指针，队头指针指向第一个元素，队尾指针指向队尾元素的下一个元素
    75.     int tag;
    76. }Queue;
    77.  
    78. //初始化
    79. int InitQueue(Queue &a){
    80.     a.front = 0;
    81.     a.rear = 0;
    82.     a.tag = 0;  //初始队列是空
    83.     return 1;
    84. } 
    85. //判断栈和队列是否为空
    86. bool IsQueueEmpty(Queue q){
    87.     if(q.tag == 0 && q.front==q.rear)
    88.         return true;
    89.     else
    90.         return false;
    91. }
    92. //插入
    93. int InsertQueue(Queue &a, int x){
    94.     if(a.front == a.rear && a.tag == 1){
    95.         printf("当前队列已满！");
    96.         return 0;
    97.     }
    98.     else{
    99.         a.data[a.rear] = x;
    100.         a.tag = 1;  //插入队列tag置1
    101.         a.rear = (a.rear + 1) % MAXSIZE;
    102.         return 1;
    103.     }  
    104. }
    105. //删除
    106. int DeleteQueue(Queue &a){
    107. 	int x;
    108. 	if(a.front == a.rear && a.tag == 0){
    109.         printf("当前队列已空！");
    110.     }
    111.     else{
    112.         x = a.data[a.front];
    113.         a.tag = 0;  //删除队列tag置0
    114.         a.front = (a.front + 1) % MAXSIZE;  //front指针+1
    115.         return x;
    116.     }  
    117. }
    118.  
    119. void print(const GraAdjList &g){
    120. 	EdgeNode *p;
    121. 	for (int k = 0;k < g.numetex;k++){
    122. 		printf("顶点%d: ", k);
    123. 		for (p = g.adjlist[k].first; p;p = p->next){
    124.             if (p != NULL)
    125.                 printf("%d ", p->adjvex);
    126. 		}
    127.         printf("\n");
    128.     }
    129. }
    130.  
    131. //根据邻接表转换成矩阵
    132. void Graphtomartix(GraAdjList &g){
    133. 	EdgeNode *p;
    134. 	int a[g.numetex][g.numetex];
    135. 	//置零
    136. 	for (int i = 0; i < g.numetex;i++){
    137. 		for (int j = 0; j < g.numetex;j++)
    138. 			a[i][j] = 0;
    139. 	}
    140. 	//赋值
    141. 	for (int i = 0; i < g.numetex; i++){
    142. 		for (p = g.adjlist[i].first; p; p = p->next){
    143. 			a[i][p->adjvex] = 1;
    144. 		}
    145. 	}
    146. 	//打印
    147. 	for (int i = 0; i < g.numetex;i++){
    148. 		for (int j = 0; j < g.numetex;j++)
    149. 			printf("%d ", a[i][j]);
    150. 		printf("\n");
    151. 	}
    152. }
    153.  
    154. void BFSTraverse(GraAdjList g,int v){  //v代表广度优先从哪开始
    155. 	bool visited[g.numetex];
    156. 	Queue q;
    157. 	EdgeNode *p;
    158. 	for (int i = 0; i < g.numetex;i++)
    159. 		visited[i] = false;
    160. 	InitQueue(q);
    161. 	printf("%d", v);  //输出访问结点
    162. 	visited[v] = true;
    163. 	InsertQueue(q, v);  //进队
    164. 	while (!IsQueueEmpty(q)){
    165. 		int x = DeleteQueue(q);
    166. 		for (p = g.adjlist[x].first; p != NULL;p=p->next){
    167. 			if(visited[p->adjvex]==false){
    168. 				printf("%d", p->adjvex);
    169. 				visited[p->adjvex] = true;
    170. 				InsertQueue(q, p->adjvex);
    171. 			}
    172. 		}
    173. 	}
    174.  
    175. 	for (int i = 0; i < g.numetex;i++){  //检查连通分量
    176. 		if(visited[i] == false){
    177. 			printf("%d", i);  //输出访问结点
    178. 			visited[i] = true;
    179. 			InsertQueue(q, i);  //进队
    180. 			while (!IsQueueEmpty(q)){
    181. 				int x = DeleteQueue(q);
    182. 				for (p = g.adjlist[x].first; p != NULL;p=p->next){
    183. 					if(visited[p->adjvex]==false){
    184. 						printf("%d", p->adjvex);
    185. 						visited[p->adjvex] = true;
    186. 						InsertQueue(q, p->adjvex);
    187. 					}
    188. 				}
    189. 			}
    190. 		}
    191. 	}
    192. }
    193.  
    194. int main(){
    195. 	GraAdjList gralist;
    196. 	CreateAlGraph(gralist, 1);  //i=0创建有向图，i=1创建无向图
    197. 	print(gralist);
    198. 	printf("图所对应的邻接矩阵是：");
    199. 	Graphtomartix(gralist);
    200. 	printf("图的广度优先遍历序列是：");
    201. 	BFSTraverse(gralist, 0);
    202. }

    输出：

    1. 请输入顶点数和边数（无向图端点相同只需录入一条边）:8 7
    2. 请输入边（Vi,Vj）的顶点下标：0 1
    3. 请输入边（Vi,Vj）的顶点下标：0 2
    4. 请输入边（Vi,Vj）的顶点下标：1 3
    5. 请输入边（Vi,Vj）的顶点下标：1 4
    6. 请输入边（Vi,Vj）的顶点下标：2 5
    7. 请输入边（Vi,Vj）的顶点下标：2 6
    8. 请输入边（Vi,Vj）的顶点下标：4 7
    9. 顶点0: 2 1
    10. 顶点1: 4 3 0
    11. 顶点2: 6 5 0
    12. 顶点3: 1
    13. 顶点4: 7 1
    14. 顶点5: 2
    15. 顶点6: 2
    16. 顶点7: 4
    17. 0 1 1 0 0 0 0 0
    18. 1 0 0 1 1 0 0 0
    19. 1 0 0 0 0 1 1 0
    20. 0 1 0 0 0 0 0 0
    21. 0 1 0 0 0 0 0 1
    22. 0 0 1 0 0 0 0 0
    23. 0 0 1 0 0 0 0 0
    24. 0 0 0 0 1 0 0 0
    25. 图的广度优先遍历序列是：02165437
    26.  
    27. 请输入顶点数和边数（无向图端点相同只需录入一条边）:5 4
    28. 请输入边（Vi,Vj）的顶点下标：0 1
    29. 请输入边（Vi,Vj）的顶点下标：0 2
    30. 请输入边（Vi,Vj）的顶点下标：1 2
    31. 请输入边（Vi,Vj）的顶点下标：3 4
    32. 顶点0: 2 1
    33. 顶点1: 2 0
    34. 顶点2: 1 0
    35. 顶点3: 4
    36. 顶点4: 3
    37. 0 1 1 0 0
    38. 1 0 1 0 0
    39. 1 1 0 0 0
    40. 0 0 0 0 1
    41. 0 0 0 1 0
    42. 图的广度优先遍历序列是：02134
    43.  
    44. //此示例要把main最后一行改成BFSTraverse(gralist, 2)，表示从2开始广度优先遍历
    45. 请输入顶点数和边数（无向图端点相同只需录入一条边）:8 7
    46. 请输入边（Vi,Vj）的顶点下标：0 1
    47. 请输入边（Vi,Vj）的顶点下标：0 2
    48. 请输入边（Vi,Vj）的顶点下标：1 3 
    49. 请输入边（Vi,Vj）的顶点下标：1 4
    50. 请输入边（Vi,Vj）的顶点下标：2 5
    51. 请输入边（Vi,Vj）的顶点下标：2 6
    52. 请输入边（Vi,Vj）的顶点下标：4 7
    53. 顶点0: 2 1
    54. 顶点1: 4 3 0
    55. 顶点2: 6 5 0
    56. 顶点3: 1
    57. 顶点4: 7 1
    58. 顶点5: 2
    59. 顶点6: 2
    60. 顶点7: 4
    61. 0 1 1 0 0 0 0 0
    62. 1 0 0 1 1 0 0 0
    63. 1 0 0 0 0 1 1 0
    64. 0 1 0 0 0 0 0 0
    65. 0 1 0 0 0 0 0 1
    66. 0 0 1 0 0 0 0 0
    67. 0 0 1 0 0 0 0 0
    68. 0 0 0 0 1 0 0 0
    69. 图的广度优先遍历序列是：26501437

    然后我们看深度优先遍历算法：

    1. bool visited[8]; //bool visited[g.numetex]，此处修改为图的顶点数
    2. void DFS(GraAdjList g,int v){
    3. 	EdgeNode *p;
    4. 	printf("%d", v);
    5. 	visited[v] = true;
    6. 	for (p = g.adjlist[v].first; p != NULL;p = p->next){
    7. 		if(!visited[p->adjvex])
    8. 			DFS(g, p->adjvex);
    9. 	}
    10. }
    11. void DFSTraverse(GraAdjList g){  //v代表深度优先从哪开始
    12. 	for (int i = 0; i < 8;i++)  //赋初值，这里也要修改为图的顶点数
    13. 		visited[i] = false;
    14. 	for (int i = 0; i < 8;i++){  //赋初值，这里也要修改为图的顶点数
    15. 		if(!visited[i])
    16. 			DFS(g, i);
    17. 	}
    18. }
    19.  
    20. int main(){
    21. 	GraAdjList gralist;
    22. 	CreateAlGraph(gralist, 1);  //i=0创建有向图，i=1创建无向图
    23. 	print(gralist);
    24. 	printf("图所对应的邻接矩阵是：\n");
    25. 	Graphtomartix(gralist);
    26. 	printf("图的深度优先遍历序列是：");
    27. 	DFSTraverse(gralist);
    28. }

    输出：

    1. 请输入顶点数和边数（无向图端点相同只需录入一条边）:8 7
    2. 请输入边（Vi,Vj）的顶点下标：0 1
    3. 请输入边（Vi,Vj）的顶点下标：0 2
    4. 请输入边（Vi,Vj）的顶点下标：1 3
    5. 请输入边（Vi,Vj）的顶点下标：1 4
    6. 请输入边（Vi,Vj）的顶点下标：2 5
    7. 请输入边（Vi,Vj）的顶点下标：2 6
    8. 请输入边（Vi,Vj）的顶点下标：4 7
    9. 顶点0: 2 1
    10. 顶点1: 4 3 0
    11. 顶点2: 6 5 0
    12. 顶点3: 1
    13. 顶点4: 7 1
    14. 顶点5: 2
    15. 顶点6: 2
    16. 顶点7: 4
    17. 图所对应的邻接矩阵是：
    18. 0 1 1 0 0 0 0 0
    19. 1 0 0 1 1 0 0 0
    20. 1 0 0 0 0 1 1 0
    21. 0 1 0 0 0 0 0 0
    22. 0 1 0 0 0 0 0 1
    23. 0 0 1 0 0 0 0 0
    24. 0 0 1 0 0 0 0 0
    25. 0 0 0 0 1 0 0 0
    26. 图的深度优先遍历序列是：02651473

    试题1（王道6.2.6节综合题4）：

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

    和前面的练习题相比，此题几乎就是白给。。。

    1. //根据邻接表转换成矩阵
    2. void Graphtomartix(GraAdjList &g){
    3. 	EdgeNode *p;
    4. 	int a[g.numetex][g.numetex];
    5. 	//置零
    6. 	for (int i = 0; i < g.numetex;i++){
    7. 		for (int j = 0; j < g.numetex;j++)
    8. 			a[i][j] = 0;
    9. 	}
    10. 	//赋值
    11. 	for (int i = 0; i < g.numetex; i++){
    12. 		for (p = g.adjlist[i].first; p; p = p->next){
    13. 			a[i][p->adjvex] = 1;
    14. 		}
    15. 	}
    16. 	//打印
    17. 	for (int i = 0; i < g.numetex;i++){
    18. 		for (int j = 0; j < g.numetex;j++)
    19. 			printf("%d ", a[i][j]);
    20. 		printf("\n");
    21. 	}
    22. }

    输出：

    1. 请输入顶点数和边数（无向图端点相同只需录入一条边）:3 1
    2. 请输入顶点的信息：0 1 2
    3. 请输入边（Vi,Vj）的顶点下标：0 1
    4. 顶点0: 1
    5. 顶点1: 0
    6. 顶点2:
    7. 0 1 0
    8. 1 0 0
    9. 0 0 0

    试题2（王道6.3.4节综合题2）：

    设计算法判断一个无向图G是否是一棵树。

    图成为树的标准：n个顶点，n-1条边，而我们建立的图的数据结构种numetex, numedge刚好对应这两个参数，所以此题等于白给。。。

    1. //此算法判断图是不是一棵树
    2. bool ifTree(GraAdjList g){
    3. 	if(g.numetex-g.numedge==1)
    4. 		return true;
    5. 	else
    6. 		return false;
    7. }

    试题3（王道6.3.4节综合题3）：

    写出图的深度优先搜索DFS算法的非递归算法（图采用邻接表形式）。

    非递归算法，把递归转化成非递归那就上栈被：

    1. bool visited[8]; //bool visited[g.numetex]，此处修改为图的顶点数
    2.  
    3. void DFS(GraAdjList g,Sqstack S,int v){
    4. 	int x;
    5. 	EdgeNode *p;
    6. 	InsertSqstack(S, v);
    7. 	while(!IsStackEmpty(S)){
    8. 		x = DeleteSqstack(S);
    9. 		printf("%d", x);
    10. 		visited[x] = true;
    11. 		for(p = g.adjlist[x].first; p != NULL;p = p->next){
    12. 			if(visited[p->adjvex]==false){
    13. 				InsertSqstack(S, p->adjvex);
    14. 				visited[p->adjvex] = true;
    15. 			}	
    16. 		}
    17. 	}	
    18. }
    19. void DFSTraverse(GraAdjList g,Sqstack S){  //v代表深度优先从哪开始
    20. 	for (int i = 0; i < 8;i++)  //赋初值，这里也要修改为图的顶点数
    21. 		visited[i] = false;
    22. 	for (int i = 0; i < 8;i++){  //赋初值，这里也要修改为图的顶点数
    23. 		if(!visited[i])
    24. 			DFS(g, S, i);
    25. 	}
    26. }
    27.  
    28. int main(){
    29. 	GraAdjList gralist;
    30. 	CreateAlGraph(gralist, 1);  //i=0创建有向图，i=1创建无向图
    31. 	print(gralist);
    32. 	printf("图所对应的邻接矩阵是：\n");
    33. 	Graphtomartix(gralist);
    34. 	Sqstack S;
    35. 	InitStack(S);
    36. 	printf("图的深度优先遍历序列是：");
    37. 	DFSTraverse(gralist, S);
    38. }

    输出：

    1. 请输入顶点数和边数（无向图端点相同只需录入一条边）:8 7
    2. 请输入边（Vi,Vj）的顶点下标：0 1
    3. 请输入边（Vi,Vj）的顶点下标：0 2
    4. 请输入边（Vi,Vj）的顶点下标：1 3
    5. 请输入边（Vi,Vj）的顶点下标：1 4
    6. 请输入边（Vi,Vj）的顶点下标：2 5
    7. 请输入边（Vi,Vj）的顶点下标：2 6
    8. 请输入边（Vi,Vj）的顶点下标：4 7
    9. 顶点0: 2 1
    10. 顶点1: 4 3 0
    11. 顶点2: 6 5 0
    12. 顶点3: 1
    13. 顶点4: 7 1
    14. 顶点5: 2
    15. 顶点6: 2
    16. 顶点7: 4
    17. 图所对应的邻接矩阵是：
    18. 0 1 1 0 0 0 0 0
    19. 1 0 0 1 1 0 0 0
    20. 1 0 0 0 0 1 1 0
    21. 0 1 0 0 0 0 0 0
    22. 0 1 0 0 0 0 0 1
    23. 0 0 1 0 0 0 0 0
    24. 0 0 1 0 0 0 0 0
    25. 0 0 0 0 1 0 0 0
    26. 图的深度优先遍历序列是：01347256

    试题4（王道6.3.4节综合题4）：

    分别采用广度优先遍历和深度优先遍历算法判断以邻接表方式存储的有向图中是否存在由顶点i到顶点j的路径（i与j不相等）。

    此题实际上就是检查两个结点是否在一个连通分量里，把前面的for循环删掉然后加判断visited[j]语句即可。

    试题5（王道6.3.4节综合题5）：

    假设图用邻接表表示，设计算法输出从顶点i到顶点j的所有简单路径。

    此题的算法不是很好想。除了要记录每个顶点是否被访问（visited数组），还要建立path数组记录当前搜索路径。函数实现的思路是：

    1. 将当前顶点u添加到搜索路径中，并将visited[u]标记为true，表示已经访问过。
    2. 如果u等于v，说明找到了一条路径，打印路径上的顶点。
    3. 遍历顶点u的邻接点，如果邻接点w未被访问过，则递归调用FindPath函数，将w作为新的起始顶点。
    4. 重置visited[u]为false，表示当前顶点u的搜索路径已经结束。

    需要注意的是，函数调用前需要将visited数组初始化为false，path数组初始化为空。另外，函数调用时初始的d值应为-1。

    1. bool visited[4]; //bool visited[g.numetex]，此处修改为图的顶点数
    2. int path[8];
    3.  
    4. void FindPath(GraAdjList g,int u,int v,int path[],int d){
    5. 	int w;
    6. 	int i;
    7. 	EdgeNode *p;
    8. 	d = d + 1;  //搜索路径长度+1,初始为-1
    9. 	path[d] = u;  //搜索路径第d步上是u
    10. 	visited[u] = true;
    11. 	if(u == v){
    12. 		printf("找到一条路径如下：");
    13. 		for (int i = 0; i <= d;i++){
    14. 			printf("%d ", path[i]);
    15. 		}
    16. 		printf("\n");
    17. 	}
    18. 	p = g.adjlist[u].first;  //p指向u的第一个邻接点
    19. 	while(p!=NULL){
    20. 		w = p->adjvex;
    21. 		if(visited[w]==false){
    22. 			FindPath(g, w, v, path, d);
    23. 		}
    24. 		p = p->next;
    25. 	}
    26. 	visited[u] = false;  //重置
    27. }
    28.  
    29. int main(){
    30. 	GraAdjList gralist;
    31. 	CreateAlGraph(gralist, 1);  //i=0创建有向图，i=1创建无向图
    32. 	print(gralist);
    33. 	printf("图所对应的邻接矩阵是：\n");
    34. 	Graphtomartix(gralist);
    35. 	FindPath(gralist, 0, 3, path, -1);
    36. }

    输出：

    1. 请输入顶点数和边数（无向图端点相同只需录入一条边）:4 5
    2. 请输入边（Vi,Vj）的顶点下标：0 1
    3. 请输入边（Vi,Vj）的顶点下标：0 2
    4. 请输入边（Vi,Vj）的顶点下标：1 2
    5. 请输入边（Vi,Vj）的顶点下标：1 3
    6. 请输入边（Vi,Vj）的顶点下标：2 3
    7. 顶点0: 2 1
    8. 顶点1: 3 2 0
    9. 顶点2: 3 1 0
    10. 顶点3: 2 1
    11. 图所对应的邻接矩阵是：
    12. 0 1 1 0
    13. 1 0 1 1
    14. 1 1 0 1
    15. 0 1 1 0
    16. 找到一条路径如下：0 2 3
    17. 找到一条路径如下：0 2 1 3
    18. 找到一条路径如下：0 1 3
    19. 找到一条路径如下：0 1 2 3

    试题6（王道6.4.6节第6题）：

    试说明利用DFS算法如何实现有向无环图的拓扑排序。

    利用递归特性，若拓扑排序序列中，a在b之后，则递归的时候a比b靠前递归结束。利用这一特点，增设time变量，然后对time变量从大到小输出即可：

    1. bool visited[8]; //bool visited[g.numetex]，此处修改为图的顶点数
    2. int finishtime[8];
    3. int time = 0;
    4. void DFS(GraAdjList g,int v){
    5. 	EdgeNode *p;
    6. 	visited[v] = true;
    7. 	for (p = g.adjlist[v].first; p != NULL;p = p->next){
    8. 		if(!visited[p->adjvex])
    9. 			DFS(g, p->adjvex);
    10. 	}
    11. 	time = time + 1;
    12. 	finishtime[v] = time;
    13. 	printf("(%d,%d)", finishtime[v], v);
    14. }
    15. void DFSTraverse(GraAdjList g){  //v代表深度优先从哪开始
    16. 	for (int i = 0; i < 8;i++)  //赋初值，这里也要修改为图的顶点数
    17. 		visited[i] = false;
    18. 	for (int i = 0; i < 8;i++){  
    19. 		if(!visited[i])
    20. 			DFS(g, i);
    21. 	}
    22. }
    23.  
    24. int main(){
    25. 	GraAdjList gralist;
    26. 	CreateAlGraph(gralist, 0);  //i=0创建有向图，i=1创建无向图
    27. 	print(gralist);
    28. 	printf("%d", time);
    29. 	printf("图所对应的邻接矩阵是：\n");
    30. 	Graphtomartix(gralist);
    31. 	printf("图的拓扑排序序列是：");
    32. 	DFSTraverse(gralist);
    33. }

    输出：

    1. 输入顶点数和边数（无向图端点相同只需录入一条边）:8 7
    2. 请输入边（Vi,Vj）的顶点下标：0 1
    3. 请输入边（Vi,Vj）的顶点下标：1 2
    4. 请输入边（Vi,Vj）的顶点下标：2 3
    5. 请输入边（Vi,Vj）的顶点下标：3 7
    6. 请输入边（Vi,Vj）的顶点下标：4 5
    7. 请输入边（Vi,Vj）的顶点下标：5 6
    8. 请输入边（Vi,Vj）的顶点下标：6 7
    9. 顶点0: 1
    10. 顶点1: 2
    11. 顶点2: 3
    12. 顶点3: 7
    13. 顶点4: 5
    14. 顶点5: 6
    15. 顶点6: 7
    16. 顶点7:
    17. 0图所对应的邻接矩阵是：
    18. 0 1 0 0 0 0 0 0
    19. 0 0 1 0 0 0 0 0
    20. 0 0 0 1 0 0 0 0
    21. 0 0 0 0 0 0 0 1
    22. 0 0 0 0 0 1 0 0
    23. 0 0 0 0 0 0 1 0
    24. 0 0 0 0 0 0 0 1
    25. 0 0 0 0 0 0 0 0
    26. 图的拓扑排序序列是：(1,7)(2,3)(3,2)(4,1)(5,0)(6,6)(7,5)(8,4)

    所以可得到拓扑排序序列：45601237

  • 相关阅读:
    分享PPT设计思路，让你的PPT更吸睛
    【微信小程序】微信小程序跳转H5页面的实现思路与方案
    解决springboot启动jar包时加载了jar包内的配置文件
    【JS 构造|原型|原型链|继承(圣杯模式)|ES6类语法】上篇
    自动化测试用例的编写，只需要牢记7点，轻轻松松
    c++常用函数所在头文件一览
    【计算机网络】 基于TCP的简单通讯（客户端）
    Spring事务回滚核心源码解读
    动态规划题： 统计每个月兔子的总数
    JenKins使用（Linux）
  • 原文地址：https://blog.csdn.net/qq_54708219/article/details/133887506