源程序及注释
#include<iostream>
using namespace std;
#define ERROR 0
#define OK 1
typedef int Status;
#define TRUE 1
#define FALSE 0
//图的邻接矩阵（数组）存储表示
#define MaxINt 32767 //表示极大值，即无穷
#define MVNum 100 //最大顶点数
typedef int ArcType; //假设边的权值类型为整型
typedef char VertexType; //假设顶点的数据类型为字符型
typedef struct {
VertexType vexs[MVNum]; //顶点表
ArcType arcs[MVNum][MVNum]; //邻接矩阵
int vexnum, arcnum; //图的当前点数和弧数
}AMGraph;
//确定顶点在数组中的位置
Status LocateVex(AMGraph G, VertexType u)
{ /* 初始条件: 图G存在,u和G中顶点有相同特征 */
/* 操作结果: 若G中存在顶点u,则返回该顶点在图中位置;否则返回-1 */
int i;
for (i = 0; i < G.vexnum; ++i)
if (u == G.vexs[i])
return i;
return -1;
}
//采用邻接矩阵表示法，创建无向网
Status CreateUDN(AMGraph &G)
{
VertexType va, vb;
cout << "请分别输入无向网G的总顶点数(不超过100个),总边数: " << endl;
cin >> G.vexnum >> G.arcnum; //输入总点数，总边数
cout << "请分别输入" << G.vexnum << "个顶点的值(字符型数据不加空格):" << endl;
for (int i = 0; i < G.vexnum; i++)//依次输入点的信息
{
cin >> G.vexs[i];
}
for (int i = 0; i < G.vexnum; i++) // 初始化邻接矩阵
{
for (int j = 0; j < G.vexnum; j++)
{
G.arcs[i][j] = MaxINt; // 边的权值均置为极大值
}
}
cout << "请分别输入每条边的两个端点和这条边的权值(以空格作为间隔)：" << endl;
for (int k = 0; k < G.arcnum; k++)
{
ArcType w;
cout << "第" << k + 1 << "条：";
cin >> va >> vb >> w; //输入一条边依附的顶点及权值
int i = LocateVex(G, va);
int j = LocateVex(G, vb);
if (i == -1 || j == -1)return(0);
G.arcs[i][j] = w;
G.arcs[j][i] = G.arcs[i][j];
}
return OK;
}
//输出邻接矩阵
Status Traverse(AMGraph G)
{
cout << "构造的邻接矩阵为：" << endl;
for (int i = 0; i < G.vexnum; i++)
{
for (int j = 0; j < G.vexnum; j++)
{
cout << G.arcs[i][j] << " ";
}
cout << endl;
}
return OK;
}
//深度优先遍历
bool visited[MVNum];
//访问标志数组，其初值为“false”
Status DFS_AM(AMGraph G, int v) { //图G为邻接矩阵类型
int w;
cout << G.vexs[v] << " "; visited[v] = true; //访问第v个顶点
for (w = 0; w < G.vexnum; w++) //依次检查邻接矩阵v所在的行
if ((G.arcs[v][w] != 0) && (!visited[w]))
DFS_AM(G, w);
//w是v的邻接点，如果w未访问，则递归调用DFS
return OK;
}
Status DFSTraverse(AMGraph G) {
int v;
for (v = 0; v < G.vexnum; ++v)
visited[v] = false;
for (v = 0; v < G.vexnum; ++v)
if (!visited[v]) DFS_AM(G, v);
return OK;
//对尚未访问的顶点调用DFS
}//DFSTraverse
#define QElemType int
//队列的链式存储结构
typedef struct QNode
{
QElemType data;
struct QNode *next;
}QNode, *QueuePtr;
typedef struct
{
QueuePtr front; //队头指针
QueuePtr rear; //队尾指针
}LinkQueue;
//初始化
Status InitQueue(LinkQueue &Q)
{//构造一个空队列Q
Q.front = Q.rear = new QNode; //生成新结点作为头结点，队头和队尾指针指向此结点
Q.front->next = NULL; //头结点的指针域置空
return OK;
}
//入队
Status EnQueue(LinkQueue &Q, QElemType e)
{//插入元素e为Q的新的队尾元素
QueuePtr p = new QNode; //为入队元素分配结点空间，用指针p指向
p->data = e; //将新结点数据域置为e
p->next = NULL; Q.rear->next = p; //将新结点插入到队尾
Q.rear = p; //修改队尾指针
return OK;
}
//判断队列是否为空
Status QueueEmpty(LinkQueue Q) {
//判断队列为空
if (Q.front == Q.rear)
return(true);
else
return(false);
}
//出队
Status DeQueue(LinkQueue &Q, QElemType &e)
{//删除Q的队头元素， 用e返回其值
if (Q.front == Q.rear) return ERROR; //若队列空， 则返回ERROR
QueuePtr p = Q.front->next; //p指向队头元素
e = p->data; //e保存队头元素的值
Q.front->next = p->next; //修改头指针
if (Q.rear == p) //最后一个元素被删， 队尾指针指向头结点
{
Q.rear = Q.front;
}
delete p; //释放原队头元素的空间
return OK;
}
//广度优先遍历
void BFS_AM(AMGraph G, int v)
{
int u, w;
LinkQueue Q;
cout << G.vexs[v] << " ";
visited[v] = true;
InitQueue(Q);
EnQueue(Q, v);
while (!QueueEmpty(Q)) {
DeQueue(Q, u);
for (w = 0; w < G.vexnum; w++) //依次检查邻接矩阵v所在的行
if ((G.arcs[v][w] != 0) && (!visited[w])) {
cout << G.vexs[w] << " "; visited[w] = true;
EnQueue(Q, w);
}
}//while
} //BFS
void BFSTraverse(AMGraph G) {
int v;
for (v = 0; v < G.vexnum; ++v)
visited[v] = false;
for (v = 0; v < G.vexnum; ++v)
if (!visited[v]) BFS_AM(G, v);
//对尚未访问的顶点调用BFS
}//BFSTraverse
Status main()
{
AMGraph G;
//采用邻接矩阵表示法，创建无向网
CreateUDN(G);
//输出邻接矩阵
Traverse(G);
//深度优先遍历
cout << "深度优先遍历序列为:" << endl;
DFSTraverse(G);
cout << endl;
//广度优先遍历
cout << "广度优先遍历序列为:" << endl;
BFSTraverse(G);
cout << endl;
system("pause");
return OK;
}
运行结果
