大话数据结构之图

typedef char VertexType; 			/* 顶点类型应由用户定义  */
typedef int EdgeType; 				/* 边上的权值类型应由用户定义 */
#define MAXVEX 100 					/* 最大顶点数，应由用户定义 */
#define INFINITY 65535				/* 用65535来代表∞ */
typedef struct
{
	VertexType vexs[MAXVEX]; 		/* 顶点表 */
	EdgeType arc[MAXVEX][MAXVEX];	/* 邻接矩阵，可看作边表 */
	int numNodes, numEdges; 		/* 图中当前的顶点数和边数  */
}MGraph;

/* 建立无向网图的邻接矩阵表示 */
void CreateMGraph(MGraph *G)
{
	int i,j,k,w;
	printf("输入顶点数和边数:\n");
	scanf("%d,%d",&G->numNodes,&G->numEdges); 		/* 输入顶点数和边数 */
	for(i = 0;i <G->numNodes;i++) 					/* 读入顶点信息,建立顶点表 */
		scanf(&G->vexs[i]);
	for(i = 0;i <G->numNodes;i++)
		for(j = 0;j <G->numNodes;j++)
			G->arc[i][j]=INFINITY;					/* 邻接矩阵初始化 */
	for(k = 0;k <G->numEdges;k++) 					/* 读入numEdges条边，建立邻接矩阵 */
	{
		printf("输入边(vi,vj)上的下标i，下标j和权w:\n");
		scanf("%d,%d,%d",&i,&j,&w); 				/* 输入边(vi,vj)上的权w */
		G->arc[i][j]=w; 
		G->arc[j][i]= G->arc[i][j]; 				/* 因为是无向图，矩阵对称 */
	}
}

typedef char VertexType; 	/* 顶点类型应由用户定义 */
typedef int EdgeType; 		/* 边上的权值类型应由用户定义 */

typedef struct EdgeNode 	/* 边表结点  */
{
	int adjvex;    			/* 邻接点域,存储该顶点对应的下标 */
	EdgeType info;			/* 用于存储权值,对于非网图可以不需要 */
	struct EdgeNode *next; 	/* 链域,指向下一个邻接点 */
}EdgeNode;

typedef struct VertexNode 	/* 顶点表结点 */
{
	VertexType data; 		/* 顶点域,存储顶点信息 */
	EdgeNode *firstedge;	/* 边表头指针 */
}VertexNode, AdjList[MAXVEX];
``

```c
typedef struct
{
	AdjList adjList; 
	int numNodes,numEdges; 	/* 图中当前顶点数和边数 */
}GraphAdjList;

/* 建立图的邻接表结构 */
void  CreateALGraph(GraphAdjList *G)
{
	int i,j,k;
	EdgeNode *e;
	printf("输入顶点数和边数:\n");
	scanf("%d,%d",&G->numNodes,&G->numEdges); 	/* 输入顶点数和边数 */
	for(i = 0;i < G->numNodes;i++) 				/* 读入顶点信息,建立顶点表 */
	{
		scanf(&G->adjList[i].data); 			/* 输入顶点信息 */
		G->adjList[i].firstedge=NULL; 			/* 将边表置为空表 */
	}
	
	
	for(k = 0;k < G->numEdges;k++)				/* 建立边表 */
	{
		printf("输入边(vi,vj)上的顶点序号:\n");
		scanf("%d,%d",&i,&j); 					/* 输入边(vi,vj)上的顶点序号 */     
		e=(EdgeNode *)malloc(sizeof(EdgeNode)); /* 向内存申请空间,生成边表结点 */     
		e->adjvex=j;							/* 邻接序号为j */                  
		e->next=G->adjList[i].firstedge;		/* 将e的指针指向当前顶点上指向的结点 */
		G->adjList[i].firstedge=e;				/* 将当前顶点的指针指向e */          
		e=(EdgeNode *)malloc(sizeof(EdgeNode)); /* 向内存申请空间,生成边表结点 */     
		e->adjvex=i;							/* 邻接序号为i */                  
		e->next=G->adjList[j].firstedge;		/* 将e的指针指向当前顶点上指向的结点 */
		G->adjList[j].firstedge=e;				/* 将当前顶点的指针指向e */           
	}
}

#define MAXVEX 9
Boolean visited[MAXVEX]; 				/* 访问标志的数组 */

/* 邻接矩阵的深度优先递归算法 */
void DFS(MGraph G, int i)
{
	int j;
 	visited[i] = TRUE;
 	printf("%c ", G.vexs[i]);			/* 打印顶点，也可以其它操作 */
	for(j = 0; j < G.numVertexes; j++)
		if(G.arc[i][j] == 1 && !visited[j])
 			DFS(G, j);					/* 对为访问的邻接顶点递归调用 */
}

/* 邻接矩阵的深度遍历操作 */
void DFSTraverse(MGraph G)
{
	int i;
 	for(i = 0; i < G.numVertexes; i++)
 		visited[i] = FALSE; 			/* 初始所有顶点状态都是未访问过状态 */
	for(i = 0; i < G.numVertexes; i++)
 		if(!visited[i]) 				/* 对未访问过的顶点调用DFS，若连通图仅执行一次 */ 
			DFS(G, i);
}

/* 邻接表的深度优先递归算法 */
void DFS(GraphAdjList GL, int i)
{
	EdgeNode *p;
 	visited[i] = TRUE;
 	printf("%c ",GL->adjList[i].data);	/* 打印顶点,也可以其它操作 */
	p = GL->adjList[i].firstedge;
	while(p)
	{
 		if(!visited[p->adjvex])
 			DFS(GL, p->adjvex);			/* 对为访问的邻接顶点递归调用 */
		p = p->next;
 	}
}

/* 邻接表的深度遍历操作 */
void DFSTraverse(GraphAdjList GL)
{
	int i;
 	for(i = 0; i < GL->numVertexes; i++)
 		visited[i] = FALSE; 			/* 初始所有顶点状态都是未访问过状态 */
	for(i = 0; i < GL->numVertexes; i++)
 		if(!visited[i]) 				/* 对未访问过的顶点调用DFS,若是连通图,只会执行一次 */ 
			DFS(GL, i);
}

/* 邻接矩阵的广度遍历算法 */
void BFSTraverse(MGraph G)
{
	int i, j;
	Queue Q;
	for(i = 0; i < G.numVertexes; i++)
       	visited[i] = FALSE;
    InitQueue(&Q);									/* 初始化一辅助用的队列 */
    for(i = 0; i < G.numVertexes; i++)  			/* 对每一个顶点做循环 */
    {
		if (!visited[i])							/* 若是未访问过就处理 */
		{
			visited[i]=TRUE;						/* 设置当前顶点访问过 */
			printf("%c ", G.vexs[i]);				/* 打印顶点，也可以其它操作 */
			EnQueue(&Q,i);							/* 将此顶点入队列 */
			while(!QueueEmpty(Q))					/* 若当前队列不为空 */
			{
				DeQueue(&Q,&i);						/* 将队对元素出队列，赋值给i */
				for(j=0;j<G.numVertexes;j++) 
				{ 							
													/* 判断其它顶点若与当前顶点存在 */
													/* 边且未访问过 */
					if(G.arc[i][j] == 1 && !visited[j]) 
					{ 					
 						visited[j]=TRUE;			/* 将找到的此顶点标记为已访问 */
						printf("%c ", G.vexs[j]);	/* 打印顶点 */
						EnQueue(&Q,j);				/* 将找到的此顶点入队列  */
					} 
				} 
			}
		}
	}
}

/* 邻接表的广度遍历算法 */
void BFSTraverse(GraphAdjList GL)
{
	int i;
    EdgeNode *p;
	Queue Q;
	for(i = 0; i < GL->numVertexes; i++)
       	visited[i] = FALSE;
    InitQueue(&Q);
   	for(i = 0; i < GL->numVertexes; i++)
   	{
		if (!visited[i])
		{
			visited[i]=TRUE;
			printf("%c ",GL->adjList[i].data);	/* 打印顶点,也可以其它操作 */
			EnQueue(&Q,i);
			while(!QueueEmpty(Q))
			{
				DeQueue(&Q,&i);
				p = GL->adjList[i].firstedge;	/* 找到当前顶点的边表链表头指针 */
				while(p)
				{
					if(!visited[p->adjvex])		/* 若此顶点未被访问 */
 					{
 						visited[p->adjvex]=TRUE;
						printf("%c ",GL->adjList[p->adjvex].data);
						EnQueue(&Q,p->adjvex);	/* 将此顶点入队列 */
					}
					p = p->next;				/* 指针指向下一个邻接点 */
				}
			}
		}
	}
}