【数据结构】图的基本操作——图的构造（邻接矩阵，邻接表），遍历（DFS，BFS）
邻接矩阵实现如下：
/*
主题：用邻接矩阵实现 DFS(递归) 与 BFS(非递归)
作者：Laugh
语言：C++
*******************************************
样例输出如下：
请选择图的类型(a - 无向图， b - 有向图)：a
请输入总顶点数，总边数：8 9
请依次输入点的信息：a b c d e f g h
输入一条边依附的顶点及权值 (eg: a b 6):
a b 1
a c 1
b d 1
b e 1
d h 1
e h 1
c f 1
c g 1
f g 1
打印邻接矩阵：
0 1 1 0 0 0 0 0
1 0 0 1 1 0 0 0
1 0 0 0 0 1 1 0
0 1 0 0 0 0 0 1
0 1 0 0 0 0 0 1
0 0 1 0 0 0 1 0
0 0 1 0 0 1 0 0
0 0 0 1 1 0 0 0
请选择遍历方式(1.深度优先搜索; 2.广度优先搜索)：
1
DFS：a b d h e c f g
BFS: a b c d e f g h
*/
#include <iostream>
#include <queue>
using namespace std;
#define OK 1
typedef int Status;
/* ————图的邻接矩阵存储表示 ————*/
#define MaxInt 32767 // 表示极大值
#define MVNum 100 // 最大顶点数
bool visited[MVNum]; // 访问标志数组，其初值为 “false”
typedef char VerTexType; // 假设顶点的数据类型为字符型
typedef int ArcType; // 假设边的权值类型为整型
typedef struct {
VerTexType vexs[MVNum]; // 顶点表
ArcType arcs[MVNum][MVNum]; // 邻接矩阵
int vexnum, arcnum; // 图的当前点数和边数
} AMGraph;
int LocateVex(AMGraph G, VerTexType u) {
/* 存在则返回 u 在顶点表中的下标；否则返回 -1 */
for (int i = 0; i < G.vexnum; i++)
if (u == G.vexs[i])
return i;
return -1;
}
/* ————采用邻接矩阵表示法创建无向网 ————*/
Status CreateUDN(AMGraph &G) {
int i, j, k;
char flag;
ArcType w;
VerTexType v1, v2;
cout << "请选择图的类型(a - 无向图， b - 有向图)：";
cin >> flag;
cout << "请输入总顶点数，总边数：";
cin >> G.vexnum >> G.arcnum; // 输入总顶点数，总边数
cout << "请依次输入点的信息：";
for (i = 0; i < G.vexnum; i++) // 依次输入点的信息
cin >> G.vexs[i];
for (i = 0; i < G.vexnum; i++) // 初始化邻接矩阵，边的权值均置为极大值 MaxInt
for (j = 0; j < G.vexnum; j++)
G.arcs[i][j] = MaxInt;
cout << "输入一条边依附的顶点及权值 (eg: a b 6): " << endl;
for (k = 0; k < G.arcnum; k++) { // 构造邻接矩阵
cin >> v1 >> v2 >> w; // 输入一条边依附的顶点及权值
i = LocateVex(G, v1); j = LocateVex(G, v2); // 确定 v1 和 v2 在 G 中的位置，即顶点数组的下标
G.arcs[i][j] = w; // 边 <v1, v2> 的权值为 w
if (flag == 'a')
G.arcs[j][i] = G.arcs[i][j]; // 置 <v1, v2> 的对称边 <v2, v1> 的权值为 w
}
return OK;
}
/* 返回顶点v的第一个邻接顶点序号 */
int FirstAdjVex(AMGraph G, int v) {
for(int i = 0; i < G.vexnum; i++)
if(G.arcs[v][i] == 1)
return i;
return -1;
}
/* 返回顶点v的相对于w的下一个邻接顶点序号 */
int NextAdjVex(AMGraph G, int v, int w) {
for(int i = w + 1; i < G.vexnum; i++)
if(G.arcs[v][i] == 1)
return i;
return -1;
}
void DFS(AMGraph G, int v) {
visited[v]=true;
cout<<G.vexs[v]<<" ";
for(int w=FirstAdjVex(G, v); w>=0; w=NextAdjVex(G, v, w))
if(!visited[w])
DFS(G, w);
}
/* 深搜 */
void DFSTraverse(AMGraph G) {
for(int i = 0; i < G.vexnum; i++)
visited[i] = false;
for(int i = 0; i < G.vexnum; i++)
if(!visited[i])
DFS(G, i);
}
/* 广搜,类似于树的层次遍历 */
void BFSTraverse(AMGraph G) {
for(int i = 0; i < G.vexnum; i++)
visited[i] = false;
queue<int> q;
for(int i = 0; i < G.vexnum; i++) {
if(!visited[i]) {
visited[i] = true;
q.push(i);
while(!q.empty()) {
int v = q.front();
q.pop();
cout << G.vexs[v] << " ";
for(int w = FirstAdjVex(G, v); w >= 0; w = NextAdjVex(G, v, w)) {
if(!visited[w]) {
visited[w] = true;
q.push(w);
}
}
}
}
}
}
int main() {
AMGraph G;
CreateUDN(G);
cout << "打印邻接矩阵：" << endl;
for (int i = 0; i < G.vexnum; i++) {
for (int j = 0; j < G.vexnum; j++) {
if (G.arcs[i][j] != MaxInt)
cout << G.arcs[i][j] << " ";
else cout << '0' << " ";
}
cout << endl;
}
int flag;
cout << "请选择遍历方式(1.深度优先搜索; 2.广度优先搜索)：\n";
cin >> flag;
switch(flag) {
case 1:
cout << "DFS：";
DFSTraverse(G);
cout << endl;
break;
case 2:
cout << "BFS：";
BFSTraverse(G);
cout << endl;
}
return 0;
}邻接表实现如下：
/*
主题：用邻接表实现 DFS(递归) 与 BFS(非递归)
作者：Laugh
语言：C++
*******************************************
样例输出如下：
请输入顶点数和边数：8 9
请输入顶点：v1 v2 v3 v4 v5 v6 v7 v8
请输入边：
v1 v2
v1 v3
v2 v4
v2 v5
v4 v8
v5 v8
v3 v6
v3 v7
v6 v7
打印邻接表如下：
v1->v3->v2
v2->v5->v4->v1
v3->v7->v6->v1
v4->v8->v2
v5->v8->v2
v6->v7->v3
v7->v6->v3
v8->v5->v4
请选择遍历方式(1.深度优先搜索; 2.广度优先搜索)：1
DFS：v1 v3 v7 v6 v2 v5 v8 v4
BFS: v1 v3 v2 v7 v6 v5 v4 v8
*/
#include <iostream>
#include <string>
#include <queue>
using namespace std;
bool visited[10];
/* 表结点 */
typedef struct ArcNode {
int adjvex; // 该弧所指向的顶点的位置
ArcNode *nextarc; // 指向下一条弧的指针
} ArcNode;
/* 头结点 */
typedef struct VNode {
string data; // 顶点信息
ArcNode* firstarc; // 第一个表结点的地址，指向第一条依附该顶点的弧的指针
} VNode, AdjList[10];
typedef struct {
AdjList vertices;
int vexnum, arcnum; // 图的顶点数和弧数
} ALGraph;
/* 返回顶点u在图中的位置 */
int LocateVex(ALGraph G, string u) {
for(int i = 0; i < G.vexnum; i++)
if(G.vertices[i].data == u)
return i;
return -1;
}
/* 构造无向图 */
void CreateUDG(ALGraph &G) {
string v1, v2;
int i, j, k;
cout << "请输入顶点数和边数：";
cin >> G.vexnum >> G.arcnum;
cout << "请输入顶点：";
for(i = 0; i < G.vexnum; i++) {
cin >> G.vertices[i].data;
G.vertices[i].firstarc = NULL;
}
cout << "请输入边：";
cout << endl;
for(k = 0; k < G.arcnum; k++) {
cin >> v1 >> v2;
i = LocateVex(G, v1);
j = LocateVex(G, v2);
/* 插入v1的邻接表,为了提高效率，总在表头插入结点 */
ArcNode *arc = new ArcNode;
arc->adjvex = j;
arc->nextarc = G.vertices[i].firstarc;
G.vertices[i].firstarc = arc;
/* 插入v2的邻接表,为了提高效率，总在表头插入结点 */
arc = new ArcNode;
arc->adjvex = i;
arc->nextarc = G.vertices[j].firstarc;
G.vertices[j].firstarc = arc;
}
}
/* 打印邻接表 */
void Print(ALGraph G) {
cout<<"打印邻接表如下：" << endl;
/* 遍历每个顶点的邻接表 */
for(int i = 0; i < G.vexnum; i++) {
cout << G.vertices[i].data;
ArcNode *p = G.vertices[i].firstarc;
while(p) {
cout << "->" << G.vertices[p->adjvex].data;
p = p->nextarc;
}
cout<<endl;
}
}
/* 返回顶点v的第一个邻接点序号 */
int FirstAdjVex(ALGraph G, int v) {
ArcNode *p=G.vertices[v].firstarc;
if(p)
return p->adjvex;
else
return -1;
}
/* 返回顶点v的相对于w的下一个邻接点序号 */
int NextAdjVex(ALGraph G, int v, int w) {
ArcNode* p = G.vertices[v].firstarc;
while(p) {
if(p->adjvex == w)
break;
p = p->nextarc;
}
if(p->adjvex != w || !p->nextarc)//如果没找到w或者w是最后一个邻接点
return -1;
return p->nextarc->adjvex;
}
void DFS(ALGraph G, int v) {
visited[v] = true;
cout << G.vertices[v].data << " ";
for(int w = FirstAdjVex(G, v); w >= 0; w = NextAdjVex(G, v, w))
if(!visited[w])
DFS(G, w);
}
void DFSTraverse(ALGraph G) {
for(int i = 0; i < G.vexnum; i++)
visited[i] = false;
for(int i = 0; i < G.vexnum; i++)
if(!visited[i])
DFS(G, i);
}
void BFSTraverse(ALGraph G) {
queue<int> q;
for(int i = 0; i < G.vexnum; i++)
visited[i] = false;
for(int i = 0; i < G.vexnum; i++) {
if(!visited[i]) {
q.push(i);
visited[i] = true;
while(!q.empty()) {
int v = q.front();
q.pop();
cout << G.vertices[v].data << " ";
for(int w = FirstAdjVex(G, v); w >= 0; w = NextAdjVex(G, v, w)) {
if (!visited[w]) {
q.push(w);
visited[w] = true;
}
}
}
}
}
}
int main()
{
ALGraph G;
CreateUDG(G);
Print(G);
int flag;
cout << "请选择遍历方式(1.深度优先搜索; 2.广度优先搜索)：\n";
cin >> flag;
switch(flag) {
case 1:
cout << "DFS：";
DFSTraverse(G);
cout << endl;
break;
case 2:
cout << "BFS：";
BFSTraverse(G);
cout << endl;
}
return 0;
}
