图的建立
1.邻接矩阵
/*
*有向图、无向图邻接矩阵形式
*目的：编程实现有向图和无向图的邻接矩阵形式，并掌握其原理
**
*Graph.h
*/
#ifndef _GRAPH_H_
#define _GRAPH_H_
#include <stdio.h>
#include <stdlib.h>
//图的顶点个数
#define MAX_VEX_NUM 10
//图的顶点的数据类型
typedef char VexData;
//图的种类
typedef enum{DG,DN,AG,AN}GraphKind; //DG为有向图，DN为有向网，AG为无向图，AN为无向网
//图的邻接矩阵结点结构体
typedef struct _ArcNode
{
int adj;
}ArcNode;
//图的存储结构结构体
typedef struct _AdjMatrix
{
VexData vex[MAX_VEX_NUM]; //图的顶点数组
ArcNode arc[MAX_VEX_NUM][MAX_VEX_NUM]; //图的邻接矩阵
int vexNum; //图的顶点个数
int arcNum; //图的边的个数
}AdjMatrix;
/*
***************************************************************
* 根据顶点值求顶点的下标 *
***************************************************************
*/
int LocateGraph(AdjMatrix G,VexData e)
{
for (int i = 0; i < G.vexNum; i++)
{
if (e == G.vex[i])
{
return i;
}
}
return -1;
}
/*
***************************************************************
* 创建无向图 *
***************************************************************
*/
void CreateAGGraph(AdjMatrix *G)
{
//定义保存用户输入边的两个顶点的变量
VexData v1, v2;
//定义找到用户输入的边的两个顶点的下标
int m = -1, n = -1;
//邻接矩阵的初始化
for (int i = 0; i < MAX_VEX_NUM; i++)
{
for (int j = 0; j < MAX_VEX_NUM; j++)
{
G->arc[i][j].adj = 0;
}
}
printf("请输入要创建的无向图的顶点数和边数:");
scanf("%d%d%*c", &G->vexNum, &G->arcNum);
//输入要创建的顶点
for (int i = 0; i < G->vexNum; i++)
{
printf("请输入第 %d 个顶点:", i + 1);
scanf("%c%*c", &G->vex[i]);
}
//输入边
for (int i = 0; i < G->arcNum; i++)
{
printf("请输入第 %d 条边(格式为a--b)：", i + 1);
scanf("%c--%c%*c", &v1, &v2);
m = LocateGraph(*G, v1);
n = LocateGraph(*G, v2);
if (m == -1 || n == -1)
{
printf("你输入的这条边不存在，请重新输入\n");
i--;
continue;
}
G->arc[m][n].adj = G->arc[n][m].adj = 1;
}
}
/*
***************************************************************
* 创建有向图 *
***************************************************************
*/
void CreateDGGraph(AdjMatrix *G)
{
//定义保存用户输入边的两个顶点的变量
VexData v1, v2;
//定义找到用户输入的边的两个顶点的下标
int m = -1, n = -1;
//邻接矩阵的初始化
for (int i = 0; i < MAX_VEX_NUM; i++)
{
for (int j = 0; j < MAX_VEX_NUM; j++)
{
G->arc[i][j].adj = 0;
}
}
printf("请输入要创建的有向图的顶点数和边数:");
scanf("%d%d%*c", &G->vexNum, &G->arcNum);
//输入要创建的顶点
for (int i = 0; i < G->vexNum; i++)
{
printf("请输入第 %d 个顶点:", i + 1);
scanf("%c%*c", &G->vex[i]);
}
//输入边
for (int i = 0; i < G->arcNum; i++)
{
printf("请输入第 %d 条边(格式为a--b)：", i + 1);
scanf("%c--%c%*c", &v1, &v2);
m = LocateGraph(*G, v1);
n = LocateGraph(*G, v2);
if (m == -1 || n == -1)
{
printf("你输入的这条边不存在，请重新输入\n");
i--;
continue;
}
G->arc[m][n].adj = 1;
}
}
/*
***************************************************************
* 输出图的顶点表和邻接矩阵 *
***************************************************************
*/
void PrintGraph(AdjMatrix G)
{
printf("图的顶点表:\n");
for (int i = 0; i < G.vexNum; i++)
{
printf("%c ", G.vex[i]);
}
printf("\n图的邻接矩阵表:\n");
for (int i = 0; i < G.vexNum; i++)
{
for (int j = 0; j < G.vexNum; j++)
{
printf("%4d", G.arc[i][j].adj);
}
printf("\n");
}
printf("\n");
}
#endif#include "MarrixGraph.h"
int main()
{
AdjMatrix AG,DG;
//创建无向图
CreateAGGraph(&AG);
PrintGraph(AG);
//创建有向图
CreateDGGraph(&DG);
PrintGraph(DG);
return 0;
}
2.邻接表
/*
*图的邻接表
*目的：编程实现图的邻接表，并掌握其原理
**
*Graph.h
*/
#ifndef _GRAPH_H_
#define _GRAPH_H_
#include <stdio.h>
#include <stdlib.h>
//图的邻接表的顶点个数
#define MAX_VEX_NUM 10
//图的邻接表中的顶点的数据类型
typedef char VexData;
//图的邻接表的边表结点
typedef struct _ArcNode
{
VexData vex; //弧头结点
int weight; //权值
struct _ArcNode *next; //指针域
}ArcNode;
//图的邻接表的顶点结构体
typedef struct _VexNode
{
VexData vex; //顶点
ArcNode *pNext; //指针域
}VexNode;
//图的邻接表的结构体
typedef struct _VexGraph
{
VexNode vex[MAX_VEX_NUM]; //图的邻接表的顶点
int vexNum; //图的顶点个数
int arcNum; //图的边的个数
}VexGraph;
/*
*************************************************************
* 根据顶点来求得该顶点在顶点表中的下标 *
*************************************************************
*/
int LocateGraph(VexGraph G,VexData e)
{
for (int i = 0; i < G.vexNum; i++)
{
if (e == G.vex[i].vex)
{
return i;
}
}
return -1;
}
/*
*************************************************************
* 有向图的邻接表的创建 *
*************************************************************
*/
void CreateDGGraph(VexGraph *G)
{
//定义变量，用户输入的边的两个顶点
VexData v1, v2;
//定义变量，接收收到的顶点的下标
int m = -1, n = -1;
//定义边表结点指针变量
ArcNode *p = NULL,*q = NULL;
//用户输入顶点和边的数目
printf("输入要创建的顶点的个数和边的个数:");
scanf("%d%d%*c", &G->vexNum, &G->arcNum);
//创建顶点
for (int i = 0; i < G->vexNum; i++)
{
printf("请输入第 %d 个顶点:",i + 1);
scanf("%c%*c", &G->vex[i].vex);
G->vex[i].pNext = NULL;
}
//输入要创建的边
for (int i = 0; i < G->arcNum; i++)
{
printf("请输入第 %d 边(例如:a--b)：", i + 1);
scanf("%c--%c%*c", &v1, &v2);
m = LocateGraph(*G, v1);
n = LocateGraph(*G, v2);
if (m == -1 || n == -1)
{
printf("输入的这条边所对应的顶点不存在,请重新输入!\n");
i--;
continue;
}
//创建新的边表结点，去存储该边
p = (ArcNode *)malloc(sizeof(ArcNode));
if (p == NULL)
{
printf("边表结点内存分配失败!\n");
exit(0);
}
p->vex = v2;
p->weight = 1;
p->next = NULL;
q = G->vex[m].pNext;
if (q == NULL)
{
G->vex[m].pNext = p;
}
else
{
while (q->next != NULL)
{
q = q->next;
}
q->next = p;
}
}
}
/*
************************************************************
* 创建无向图的邻接表 *
************************************************************
*/
void CreateAGGraph(VexGraph *G)
{
//定义变量，用户输入的边的两个顶点
VexData v1, v2;
//定义变量，接收收到的顶点的下标
int m = -1, n = -1;
//定义边表结点指针变量
ArcNode *p = NULL, *q = NULL;
//用户输入顶点和边的数目
printf("输入要创建的顶点的个数和边的个数:");
scanf("%d%d%*c", &G->vexNum, &G->arcNum);
//创建顶点
for (int i = 0; i < G->vexNum; i++)
{
printf("请输入第 %d 个顶点:", i + 1);
scanf("%c%*c", &G->vex[i].vex);
G->vex[i].pNext = NULL;
}
//输入要创建的边
for (int i = 0; i < G->arcNum; i++)
{
printf("请输入第 %d 边(例如:a--b)：", i + 1);
scanf("%c--%c%*c", &v1, &v2);
m = LocateGraph(*G, v1);
n = LocateGraph(*G, v2);
if (m == -1 || n == -1)
{
printf("输入的这条边所对应的顶点不存在,请重新输入!\n");
i--;
continue;
}
//创建新的边表结点，去存储该边
p = (ArcNode *)malloc(sizeof(ArcNode));
if (p == NULL)
{
printf("边表结点内存分配失败!\n");
exit(0);
}
p->vex = v2;
p->weight = 1;
p->next = NULL;
q = G->vex[m].pNext;
if (q == NULL)
{
G->vex[m].pNext = p;
}
else
{
while (q->next != NULL)
{
q = q->next;
}
q->next = p;
}
//创建新的边表结点，去存储该边
p = (ArcNode *)malloc(sizeof(ArcNode));
if (p == NULL)
{
printf("边表结点内存分配失败!\n");
exit(0);
}
p->vex = v1;
p->weight = 1;
p->next = NULL;
q = G->vex[n].pNext;
if (q == NULL)
{
G->vex[n].pNext = p;
}
else
{
while (q->next != NULL)
{
q = q->next;
}
q->next = p;
}
}
}
/*
************************************************************
* 图的深度优先遍历 *
************************************************************
*/
//图中顶点是否访问过的标记数组
VexData vexVisited[MAX_VEX_NUM];
void DFS(VexGraph G,int x)
{
//定义边表结点结构体指针
if (!vexVisited[x])
{
printf("[%c]", G.vex[x].vex);
vexVisited[x] = 1;
}
ArcNode *p = NULL;
p = G.vex[x].pNext;
while (p != NULL)
{
if (!vexVisited[LocateGraph(G,p->vex)])
{
printf("[%c]", p->vex);
vexVisited[LocateGraph(G,p->vex)] = 1;
DFS(G, LocateGraph(G, p->vex));
}
p = p->next;
}
}
/*
**********************************************************
* *
**********************************************************
*/
/*
**********************************************************
* 图的广度优先遍历 *
**********************************************************
*/
//定义访问标记数组
VexData vexVisited1[MAX_VEX_NUM];
#include <queue>
using namespace std;
void BFS(VexGraph G, int x)
{
//定义边表结点指针变量
ArcNode *p = NULL;
//顶点值类型变量
VexData e;
//顶点下标值
int m = -1;
//定义队列
queue<VexData> queue;
//图的顶点入队
queue.push(G.vex[0].vex);
while (!queue.empty())
{
//获得队首元素
e = queue.front();
//队首元素出队
queue.pop();
//根据顶点值，得到下标值
m = LocateGraph(G, e);
vexVisited1[m] = 1;
printf("[%c]", e);
p = G.vex[m].pNext;
while (p != NULL)
{
if (!vexVisited1[LocateGraph(G,p->vex)])
{
queue.push(p->vex);
vexVisited1[LocateGraph(G, p->vex)] = 1;
}
p = p->next;
}
}
}
#endif#include "Graph.h"
int main()
{
VexGraph DG,AG;
//创建有向邻接表图
CreateDGGraph(&DG);
//有向图的邻接矩阵的深度优先遍历
printf("DFS");
DFS(DG, 0);
printf("\n");
//有向图的广度优先遍历
printf("BFS");
BFS(DG, 0);
printf("\n");
/*
//创建无向图的邻接表图
CreateAGGraph(&AG);
//无向图的深度优先遍历
DFS(AG, 0);
printf("\n");
//无向图的广度优先遍历
BFS(AG, 0);
printf("\n");
*/
return 0;
}
图的搜索
1.DFS
/*
*图的邻接表
*目的：编程实现图的邻接表，并掌握其原理
**
*Graph.h
*/
#ifndef _GRAPH_H_
#define _GRAPH_H_
#include <stdio.h>
#include <stdlib.h>
//图的邻接表的顶点个数
#define MAX_VEX_NUM 10
//图的邻接表中的顶点的数据类型
typedef char VexData;
//图的邻接表的边表结点
typedef struct _ArcNode
{
VexData vex; //弧头结点
int weight; //权值
struct _ArcNode *next; //指针域
}ArcNode;
//图的邻接表的顶点结构体
typedef struct _VexNode
{
VexData vex; //顶点
ArcNode *pNext; //指针域
}VexNode;
//图的邻接表的结构体
typedef struct _VexGraph
{
VexNode vex[MAX_VEX_NUM]; //图的邻接表的顶点
int vexNum; //图的顶点个数
int arcNum; //图的边的个数
}VexGraph;
/*
*************************************************************
* 根据顶点来求得该顶点在顶点表中的下标 *
*************************************************************
*/
int LocateGraph(VexGraph G,VexData e)
{
for (int i = 0; i < G.vexNum; i++)
{
if (e == G.vex[i].vex)
{
return i;
}
}
return -1;
}
/*
*************************************************************
* 有向图的邻接表的创建 *
*************************************************************
*/
void CreateDGGraph(VexGraph *G)
{
//定义变量，用户输入的边的两个顶点
VexData v1, v2;
//定义变量，接收收到的顶点的下标
int m = -1, n = -1;
//定义边表结点指针变量
ArcNode *p = NULL,*q = NULL;
//用户输入顶点和边的数目
printf("输入要创建的顶点的个数和边的个数:");
scanf("%d%d%*c", &G->vexNum, &G->arcNum);
//创建顶点
for (int i = 0; i < G->vexNum; i++)
{
printf("请输入第 %d 个顶点:",i + 1);
scanf("%c%*c", &G->vex[i].vex);
G->vex[i].pNext = NULL;
}
//输入要创建的边
for (int i = 0; i < G->arcNum; i++)
{
printf("请输入第 %d 边(例如:a--b):", i + 1);
scanf("%c--%c%*c", &v1, &v2);
m = LocateGraph(*G, v1);
n = LocateGraph(*G, v2);
if (m == -1 || n == -1)
{
printf("输入的这条边所对应的顶点不存在,请重新输入!\n");
i--;
continue;
}
//创建新的边表结点，去存储该边
p = (ArcNode *)malloc(sizeof(ArcNode));
if (p == NULL)
{
printf("边表结点内存分配失败!\n");
exit(0);
}
p->vex = v2;
p->weight = 1;
p->next = NULL;
q = G->vex[m].pNext;
if (q == NULL)
{
G->vex[m].pNext = p;
}
else
{
while (q->next != NULL)
{
q = q->next;
}
q->next = p;
}
}
}
/*
************************************************************
* 创建无向图的邻接表 *
************************************************************
*/
void CreateAGGraph(VexGraph *G)
{
//定义变量，用户输入的边的两个顶点
VexData v1, v2;
//定义变量，接收收到的顶点的下标
int m = -1, n = -1;
//定义边表结点指针变量
ArcNode *p = NULL, *q = NULL;
//用户输入顶点和边的数目
printf("输入要创建的顶点的个数和边的个数:");
scanf("%d%d%*c", &G->vexNum, &G->arcNum);
//创建顶点
for (int i = 0; i < G->vexNum; i++)
{
printf("请输入第 %d 个顶点:", i + 1);
scanf("%c%*c", &G->vex[i].vex);
G->vex[i].pNext = NULL;
}
//输入要创建的边
for (int i = 0; i < G->arcNum; i++)
{
printf("请输入第 %d 边(例如:a--b):", i + 1);
scanf("%c--%c%*c", &v1, &v2);
m = LocateGraph(*G, v1);
n = LocateGraph(*G, v2);
if (m == -1 || n == -1)
{
printf("输入的这条边所对应的顶点不存在,请重新输入!\n");
i--;
continue;
}
//创建新的边表结点，去存储该边
p = (ArcNode *)malloc(sizeof(ArcNode));
if (p == NULL)
{
printf("边表结点内存分配失败!\n");
exit(0);
}
p->vex = v2;
p->weight = 1;
p->next = NULL;
q = G->vex[m].pNext;
if (q == NULL)
{
G->vex[m].pNext = p;
}
else
{
while (q->next != NULL)
{
q = q->next;
}
q->next = p;
}
//创建新的边表结点，去存储该边
p = (ArcNode *)malloc(sizeof(ArcNode));
if (p == NULL)
{
printf("边表结点内存分配失败!\n");
exit(0);
}
p->vex = v1;
p->weight = 1;
p->next = NULL;
q = G->vex[n].pNext;
if (q == NULL)
{
G->vex[n].pNext = p;
}
else
{
while (q->next != NULL)
{
q = q->next;
}
q->next = p;
}
}
}
#endif/*
*图的深度优先搜索
*目的：编程实现图的深度优先搜索，并掌握其原理
**
*main.cpp
*/
#include "Graph.h"
/*
****************************************************************
*图的深度优先搜索的基本思想： *
****************************************************************
* 图的深度优先搜索，可以打一个比方，一条路，不管通不通，先走到*
*底再说，如果走到底，发现路不通，那么，退回到上一个十字路口，重*
*新走，再走到底，直到把所有的路都走完了。（一条路走到黑）。 *
* 这样进行深度优先搜索的话，需要用到一个全局数组，去记录哪些顶*
*点访问过了，哪些没有访问过。为了记录走过的足迹，需要用栈进行保*
*存，这样，才方便路不通的时候，进行返回。 （也可以使用递归） *
****************************************************************
****************************************************************
* 深度优先搜索，使用的是图的邻接表。 *
****************************************************************
*/
//全局数组，记录哪些顶点访问过，哪些没有访问过
int visited[MAX_VEX_NUM];
void DFS(VexGraph G,int num)
{
visited[num] = 1;
//打印当前访问的这个顶点
printf("[%c]", G.vex[num].vex);
//寻找和这个顶点相关的没有被访问过的顶点
ArcNode *p = NULL;
p = G.vex[num].pNext;
while (p != NULL)
{
if (!visited[LocateGraph(G, p->vex)])
{
DFS(G, LocateGraph(G, p->vex));
}
p = p->next;
}
}
void GraphDFS(VexGraph G)
{
//全局数组的初始化
for (int i = 0; i < G.vexNum; i++)
{
visited[i] = 0;
}
//深度优先搜索
for (int j = 0; j < G.vexNum; j++)
{
//如果这个顶点没有被访问过
if (!visited[j])
{
//访问这个顶点
DFS(G, j);
}
}
}
int main()
{
VexGraph G;
CreateDGGraph(&G);
GraphDFS(G);
return 0;
}
2.BFS
/*
*图的邻接表
*目的：编程实现图的邻接表，并掌握其原理
**
*Graph.h
*/
#ifndef _GRAPH_H_
#define _GRAPH_H_
#include <stdio.h>
#include <stdlib.h>
//图的邻接表的顶点个数
#define MAX_VEX_NUM 10
//图的邻接表中的顶点的数据类型
typedef char VexData;
//图的邻接表的边表结点
typedef struct _ArcNode
{
VexData vex; //弧头结点
int weight; //权值
struct _ArcNode *next; //指针域
}ArcNode;
//图的邻接表的顶点结构体
typedef struct _VexNode
{
VexData vex; //顶点
ArcNode *pNext; //指针域
}VexNode;
//图的邻接表的结构体
typedef struct _VexGraph
{
VexNode vex[MAX_VEX_NUM]; //图的邻接表的顶点
int vexNum; //图的顶点个数
int arcNum; //图的边的个数
}VexGraph;
/*
*************************************************************
* 根据顶点来求得该顶点在顶点表中的下标 *
*************************************************************
*/
int LocateGraph(VexGraph G,VexData e)
{
for (int i = 0; i < G.vexNum; i++)
{
if (e == G.vex[i].vex)
{
return i;
}
}
return -1;
}
/*
*************************************************************
* 有向图的邻接表的创建 *
*************************************************************
*/
void CreateDGGraph(VexGraph *G)
{
//定义变量，用户输入的边的两个顶点
VexData v1, v2;
//定义变量，接收收到的顶点的下标
int m = -1, n = -1;
//定义边表结点指针变量
ArcNode *p = NULL,*q = NULL;
//用户输入顶点和边的数目
printf("输入要创建的顶点的个数和边的个数:");
scanf("%d%d%*c", &G->vexNum, &G->arcNum);
//创建顶点
for (int i = 0; i < G->vexNum; i++)
{
printf("请输入第 %d 个顶点:",i + 1);
scanf("%c%*c", &G->vex[i].vex);
G->vex[i].pNext = NULL;
}
//输入要创建的边
for (int i = 0; i < G->arcNum; i++)
{
printf("请输入第 %d 边(例如:a--b)", i + 1);
scanf("%c--%c%*c", &v1, &v2);
m = LocateGraph(*G, v1);
n = LocateGraph(*G, v2);
if (m == -1 || n == -1)
{
printf("输入的这条边所对应的顶点不存在,请重新输入!\n");
i--;
continue;
}
//创建新的边表结点，去存储该边
p = (ArcNode *)malloc(sizeof(ArcNode));
if (p == NULL)
{
printf("边表结点内存分配失败!\n");
exit(0);
}
p->vex = v2;
p->weight = 1;
p->next = NULL;
q = G->vex[m].pNext;
if (q == NULL)
{
G->vex[m].pNext = p;
}
else
{
while (q->next != NULL)
{
q = q->next;
}
q->next = p;
}
}
}
/*
************************************************************
* 创建无向图的邻接表 *
************************************************************
*/
void CreateAGGraph(VexGraph *G)
{
//定义变量，用户输入的边的两个顶点
VexData v1, v2;
//定义变量，接收收到的顶点的下标
int m = -1, n = -1;
//定义边表结点指针变量
ArcNode *p = NULL, *q = NULL;
//用户输入顶点和边的数目
printf("输入要创建的顶点的个数和边的个数:");
scanf("%d%d%*c", &G->vexNum, &G->arcNum);
//创建顶点
for (int i = 0; i < G->vexNum; i++)
{
printf("请输入第 %d 个顶点:", i + 1);
scanf("%c%*c", &G->vex[i].vex);
G->vex[i].pNext = NULL;
}
//输入要创建的边
for (int i = 0; i < G->arcNum; i++)
{
printf("请输入第 %d 边(例如:a--b)", i + 1);
scanf("%c--%c%*c", &v1, &v2);
m = LocateGraph(*G, v1);
n = LocateGraph(*G, v2);
if (m == -1 || n == -1)
{
printf("输入的这条边所对应的顶点不存在,请重新输入!\n");
i--;
continue;
}
//创建新的边表结点，去存储该边
p = (ArcNode *)malloc(sizeof(ArcNode));
if (p == NULL)
{
printf("边表结点内存分配失败!\n");
exit(0);
}
p->vex = v2;
p->weight = 1;
p->next = NULL;
q = G->vex[m].pNext;
if (q == NULL)
{
G->vex[m].pNext = p;
}
else
{
while (q->next != NULL)
{
q = q->next;
}
q->next = p;
}
//创建新的边表结点，去存储该边
p = (ArcNode *)malloc(sizeof(ArcNode));
if (p == NULL)
{
printf("边表结点内存分配失败!\n");
exit(0);
}
p->vex = v1;
p->weight = 1;
p->next = NULL;
q = G->vex[n].pNext;
if (q == NULL)
{
G->vex[n].pNext = p;
}
else
{
while (q->next != NULL)
{
q = q->next;
}
q->next = p;
}
}
}
#endif/*
*图的广度优先搜索
*目的：编程实现图的广度优先搜索，并掌握其原理
**
*main.cpp
*/
#include "Graph.h"
/*
****************************************************************
*图的广度优先搜索的基本思想： *
****************************************************************
* 图的广度优先搜索，就好像原地画圈圈，只不过这个圈圈是从中间的*
*一个基点开始，依次往外画圈，有点像原来的棒棒糖上面的花纹。 *
* 图的广度优先遍历，可以先找到一个顶点，然后，根据这个顶点，依*
*次找到这个顶点的出度，把这些出度相关的顶点，依次放到队列中。当*
*然，也需要一个全局数据，去标记哪些顶点没有访问，哪些顶点访问过*
*了。 *
****************************************************************
****************************************************************
* 图的广度优先搜素，也是采用图的邻接表。 *
****************************************************************
*/
#include <queue>
using namespace std;
int visited[MAX_VEX_NUM];
void GraphBFS(VexGraph G)
{
//定义一个队列
queue<VexData> q;
if (G.vexNum < 1)
{
return;
}
//让第一个元素的出度进入队列
q.push(G.vex[0].vex);
while (!q.empty())
{
VexData res = q.front();
q.pop();
int pos = LocateGraph(G, res);
visited[pos] = 1;
printf("[%c]", res);
ArcNode *p = NULL;
p = G.vex[pos].pNext;
while (p != NULL)
{
if (!visited[LocateGraph(G, p->vex)])
{
q.push(p->vex);
visited[LocateGraph(G, p->vex)] = 1;
}
p = p->next;
}
}
}
int main()
{
VexGraph G;
CreateDGGraph(&G);
GraphBFS(G);
return 0;
}
