图的基本操作

定义

/*课本第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;
}