定义
/*课本第168页的图7.13(a)的图*/
#include<stdio.h>
#include<stdlib.h>
#include<climits>
#define MAX_VERTEX_NUM 20//最大顶点个数
#define MAXQSIZE 100
bool visited[MAX_VERTEX_NUM];
typedef char InfoType;
typedef enum {DG, DNG, UDG, UDN}GraphKind; //digraph; directed network;undirected graph;undirected network
typedef int QElemType;
typedef struct ArcCell
{
int adj;//adj顶点关系类型,对无权图,用0或1表示是否相邻;对带权图,则为权值类型
InfoType *info;//该弧相关信息的指针
}ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef struct
{
int vexs[MAX_VERTEX_NUM];//顶点向量
AdjMatrix arcs;//邻接矩阵
int vexnum, arcnum;//图的当前顶点数和弧数
GraphKind kind;//图的种类标志
}MGraph;
typedef struct CloseDge
{
int adjvex;
int lowcost;
}minside[MAX_VERTEX_NUM];
typedef struct
{
QElemType *base;
int front;
int rear;
}SqQueue;
bool CreateGraph(MGraph &G);
void AdjMatrixPrint(MGraph G);
void DFS(MGraph G, int v);
void DFSTraverse(MGraph G);
void BFSTraverse(MGraph G);
int LocateVex(MGraph G, int v);
bool InitQueue(SqQueue &Q);
bool EnQueue(SqQueue &Q, QElemType e);
bool DeQueue(SqQueue &Q, QElemType &e);
bool QueueEmpty(SqQueue Q);
void MiniSpanTree_PRIM(MGraph G, int u);
int minimum(MGraph G, minside closedge);
主函数
int main()
{
MGraph G;
printf("用邻接矩阵表示法构造一个图:\n");
if(CreateGraph(G))
printf("构造图成功!\n");
else
printf("构造图不成功!\n");
printf("输出图的邻接矩阵:\n");
AdjMatrixPrint(G);
printf("深度优先遍历图,输出遍历序列:\n");
DFSTraverse(G);
printf("\n");
printf("广度优先遍历图,输出遍历序列:\n");
BFSTraverse(G);
printf("\n");
MiniSpanTree_PRIM(G, G.vexs[0]);
return 0;
}
构造一个图
bool CreateGraph(MGraph &G)
{
printf("请输入图的类型标识(0:有向图,1:有向网,2:无向图,3:无向网):\n");// GraphKind kind;
scanf("%d", &G.kind);
printf("请输入图G的顶点数和弧数:\n"); //int vexnum, arcnum;
scanf("%d%d", &G.vexnum, &G.arcnum);
if(G.vexnum == 0 || G.arcnum == 0)
return false;
if(G.kind == 0 || G.kind == 2)//初始化图的邻接矩阵 //AdjMatrix arcs;
for(int i = 0; i < G.vexnum; i ++)
for(int j = 0; j < G.vexnum; j ++)
{
G.arcs[i][j].adj = 0;
G.arcs[i][j].info = NULL;
}
else//初始化网的邻接矩阵
for(int i = 0; i < G.vexnum; i ++)
for(int j = 0; j < G.vexnum; j ++)
{
G.arcs[i][j].adj = INT_MAX;
G.arcs[i][j].info = NULL;
}
printf("请输入各个顶点的信息(将按照输入序列建立顶点向量):\n"); //int vexs[MAX_VERTEX_NUM];
for(int i = 0; i < G.vexnum; i ++)//构造顶点数组
scanf("%d", &G.vexs[i]);
printf("构造邻接矩阵\n");//构造邻接矩阵
int v1, v2;
int w;
for(int k = 0; k < G.arcnum; k ++)
{
printf("请输入第%d条弧的信息:弧尾顶点、弧头顶点、权值(若为无权图,则输入1):\n", k + 1);
scanf("%d%d%d", &v1, &v2, &w);
printf("v1=%d,v2=%d,w=%d\n", v1, v2, w);
int i = LocateVex(G, v1);
int j = LocateVex(G, v2);
G.arcs[i][j].adj = w;
if(G.kind == 2 || G.kind == 3)//无向图和无向网对称
G.arcs[j][i].adj = w;
}
return true;
}
LocateVex(MGraph G, int v)
int LocateVex(MGraph G, int v)
{
int i;
for(i = 0; i < G.vexnum; i ++)
if(G.vexs[i] == v)
return i;
return -1;
}
输出图的邻接矩阵
void AdjMatrixPrint(MGraph G)//输出邻接矩阵
{
for(int i = 0; i < G.vexnum; i ++)
{
for(int j = 0; j < G.vexnum; j ++)
printf("%d ", G.arcs[i][j].adj);
printf("\n");
}
}
深度优先遍历图,输出遍历序列;
void DFSTraverse(MGraph G)
{
int v;
for(v = 0; v < G.vexnum; v ++)
visited[v] = false;
for(v = 0; v < G.vexnum; v ++)
if(!visited[v])
DFS(G, v);
}
void DFS(MGraph G, int v)
{
visited[v] = true;
printf("%d ", G.vexs[v]);
for(int i = 0; i < G.vexnum; i ++)
if(G.arcs[v][i].adj != 0 && G.arcs[v][i].adj != INT_MAX)
if(!visited[i])
DFS(G, i);
}
广度优先遍历图,输出遍历序列;
void BFSTraverse(MGraph G)
{
int v;
int u;
for(v = 0; v < G.vexnum; v ++)
visited[v] = false;
SqQueue Q;
InitQueue(Q);
for(v = 0; v < G.vexnum; v ++)
if(!visited[v])
{
visited[v] = true;
printf("%d ", G.vexs[v]);
EnQueue(Q, v);
while(!QueueEmpty(Q))
{
DeQueue(Q, u);
for(int i = 0; i < G.vexnum; i ++)
if(G.arcs[u][i].adj != 0 && G.arcs[u][i].adj != INT_MAX)
if(!visited[i])
{
visited[i] = true;
printf("%d ", G.vexs[i]);
EnQueue(Q, i);
}//if
}//while
}//if
}//BFSTraverse
用prim算法求其最小生成树,并输出最小生成树的顶点序列。
void MiniSpanTree_PRIM(MGraph G, int u)
{
//用普里姆算法从第u个顶点出发构造网G的最小生成树,输出T的各条边
//按照课本第174页图7.16(a)的无向网
minside closedge;
int i;
int k;
k = LocateVex(G, u);
int j;
for(j = 0; j < G.vexnum; j ++)//辅助数组初始化
if(j != k)
{
closedge[j].adjvex = u;
closedge[j].lowcost = G.arcs[k][j].adj;
}
closedge[k].lowcost = 0;//初始,U={u}
printf("最小生成树的各条边为:\n");
for(i = 1; i < G.vexnum; i ++)//选择其余G.vexnum-1个顶点
{
k = minimum(G, closedge);//求出其余T的下一个结点:第k顶点
printf("%d-%d\n", closedge[k].adjvex, G.vexs[k]);//输出生成树的边
closedge[k].lowcost = 0;//第k个顶点并入U集
for(j = 0; j < G.vexnum; j ++)//新定点并入U集后重新选择最小边
if(G.arcs[k][j].adj < closedge[j].lowcost)
{
closedge[j].adjvex = G.vexs[k];
closedge[j].lowcost = G.arcs[k][j].adj;
}
}
}
int minimum(MGraph G, minside closedge)//求closedge.lowcost的最小正值
{
int i=0, j, k, min;
while(!closedge[i].lowcost)
i ++;
min=closedge[i].lowcost; //第一个不为0的值
k=i;
for(j=i+1;j<G.vexnum;j++)
if(closedge[j].lowcost>0)
if(min>closedge[j].lowcost)
{
min=closedge[j].lowcost;
k=j;
}
return k;
}
附录:BFS队列操作
bool InitQueue(SqQueue &Q)
{
Q.base = (QElemType *)malloc(MAXQSIZE * sizeof(QElemType));
if(!Q.base)
return false;
Q.front = Q.rear = 0;
return true;
}
bool EnQueue(SqQueue &Q, QElemType e)
{
if((Q.rear + 1) % MAXQSIZE == Q.front)
return false;
Q.base[Q.rear] = e;
Q.rear = (Q.rear + 1 + MAXQSIZE) % MAXQSIZE;
return true;
}
bool DeQueue(SqQueue &Q, QElemType &e)
{
if(Q.front == Q.rear)
return false;
e = Q.base[Q.front];
Q.front = (Q.front + 1 + MAXQSIZE) % MAXQSIZE;
return true;
}
bool QueueEmpty(SqQueue Q)
{
if(Q.front == Q.rear)
return true;
else
return false;
}