图的一些基本算法

#include <stdio.h>
#include <queue>
using namespace std;

#define MAXSIZE 100
#define INFINITY 65535

typedef char VertexType;
typedef int EdgeType;

/*用链表表示*/
typedef struct EdgeNode
{
	int adjvex;
	EdgeType weight;
	struct EdgeNode *next;
}EdgeNode;

typedef struct VertexNode
{
	VertexType data;
	EdgeNode *firstEdge;
}VertexNode, AdjList[MAXSIZE];

typedef struct
{
	AdjList adjList;
	int numVertexes, numEdges;
}GraphAdjList;

/*用数组表示*/
typedef struct
{
	VertexType vexs[MAXSIZE];
	EdgeType arc[MAXSIZE][MAXSIZE];
	int numVertexes, numEdges;
}MGraph;

/*用边数组表示*/
typedef struct
{
	int begin;
	int end;
	int weight;
}Edge;
typedef struct
{
	Edge edge[MAXSIZE];
	int numVertexes, numEdges;
}EdgeGraph;



int visited[MAXSIZE];

/*创建图，使用边数组表示*/
/*void CreateEdgeGraph(EdgeGraph *EG)
{
	int i;
	EG->numEdges = 15;
	EG->numVertexes = 9;
}*/



/*创建图，采用邻接矩阵的存储结构*/
void CreateMGraph(MGraph *G)
{
	int i, j;
	int begin, end, weight;

	G->numVertexes = 9;
	G->numEdges = 15;

	for (i = 0; i < G->numVertexes; ++i)
	{
		for (j = 0; j < G->numVertexes; j++)
		{
			G->arc[i][j] = INFINITY;
		}
	}

	G->vexs[0] = 'A';
	G->arc[0][0] = 0;
	for (i = 1; i < 9; ++i)
	{
		G->vexs[i] = G->vexs[0] + i;
		G->arc[i][i] = 0;
	}

	for (i = 0; i < G->numEdges; ++i)
	{
		scanf("%d %d %d", &begin, &end, &weight);
		G->arc[begin][end] = weight;
		G->arc[end][begin] = weight;
	}
	/*G->arc[0][1] = 10;
	G->arc[0][5] = 11;
	G->arc[1][0] = 10;
	G->arc[1][2] = 18;
	G->arc[1][6] = 16;
	G->arc[1][8] = 12;
	G->arc[2][1] = 18;
	G->arc[2][3] = 22;
	G->arc[2][8] = 8;
	G->arc[3][2] = 22;
	G->arc[3][4] = 20;
	G->arc[3][6] = 24;
	G->arc[3][7] = 16;
	G->arc[3][8] = 21;
	G->arc[4][3] = 20;
	G->arc[4][5] = 26;
	G->arc[4][7] = 7;
	G->arc[5][0] = 11;
	G->arc[5][4] = 26;
	G->arc[5][6] = 17;
	G->arc[6][1] = 16;
	G->arc[6][3] = 24;
	G->arc[6][5] = 17;
	G->arc[6][7] = 19;
	G->arc[7][3] = 16;
	G->arc[7][4] = 7;
	G->arc[7][6] = 19;
	G->arc[8][1] = 12;
	G->arc[8][2] = 8;
	G->arc[8][3] = 21;*/

#if 0
	for (i = 0; i < G->numVertexes; ++i)
	{
		for (j = 0; j < G->numVertexes; j++)
		{
			printf("%d\t", G->arc[i][j]);
		}
		printf("\n");
	}
#endif
}

/*创建图，采用邻接表的存储结构*/
void CreateGraphAdjList(GraphAdjList *GL)
{
	EdgeNode *e;
	int i;
	int begin, end, weight;
	GL->numEdges = 15;
	GL->numVertexes = 9;
	for (i = 0; i < GL->numVertexes; ++i)
	{
		GL->adjList[i].data = 'A' + i;
		GL->adjList[i].firstEdge = NULL;
	}
	for (i = 0; i < GL->numEdges; ++i)
	{
		scanf("%d %d %d", &begin, &end, &weight);

		e = (EdgeNode *)malloc(sizeof(EdgeNode));
		e->adjvex = end;
		e->weight = weight;
		e->next = GL->adjList[begin].firstEdge;
		GL->adjList[begin].firstEdge = e;

		e = (EdgeNode *)malloc(sizeof(EdgeNode));
		e->adjvex = begin;
		e->weight = weight;
		e->next = GL->adjList[end].firstEdge;
		GL->adjList[end].firstEdge = e;
	}
#if 0
	for (i = 0; i < GL->numVertexes; ++i)
	{
		printf("%c: ", GL->adjList[i].data);
		e = GL->adjList[i].firstEdge;
		while (e)
		{
			printf("%c ", GL->adjList[e->adjvex].data);
			e = e->next;
		}
		printf("\n");
	}
#endif
}




/*图的深度优先搜索，邻接矩阵*/
void DFSMGraph(MGraph *G, int i)
{
	int j;
	visited[i] = 1;
	printf("%c ", G->vexs[i]);
	for (j = 0; j < G->numVertexes; j++)
	{
		if (0 != G->arc[i][j] && G->arc[i][j] < INFINITY && !visited[j])
			DFSMGraph(G, j);
	}
}
void DFSMGraphTraverse(MGraph *G)
{
	int i;
	for (i = 0; i < G->numVertexes; ++i)
		visited[i] = 0;

	printf("树的深度优先搜索:\n");
	for (i = 0; i < G->numVertexes; ++i)
	{
		if (!visited[i])
		{
			DFSMGraph(G, i);
			printf("\n");
		}
	}
}

/*图的深度优先搜索，邻接表*/
void DFSGraphAdjList(GraphAdjList *GL, int i)
{
	EdgeNode *e;
	visited[i] = 1;
	printf("%c ", GL->adjList[i].data);
	
	e = GL->adjList[i].firstEdge;
	while (e)
	{
		if (0 == visited[e->adjvex])
			DFSGraphAdjList(GL, e->adjvex);
		e = e->next;
	}
}
void DFSGraphAdjListTraverse(GraphAdjList *GL)
{
	int i;
	
	for (i = 0; i < GL->numVertexes; ++i)
		visited[i] = 0;

	printf("树的深度优先搜索:\n");
	for (i = 0; i < GL->numVertexes; ++i)
	{
		if (0 == visited[i])
		{
			DFSGraphAdjList(GL, i);
			printf("\n");
		}
	}
}




/*图的广度优先搜索，邻接矩阵*/
void BFSMGraphTraverse(MGraph *G)
{
	int i, j, k;
	queue<int> q;

	for (i = 0; i < G->numVertexes; ++i)
		visited[i] = 0;

	/*遍历每棵树*/
	for (i = 0; i < G->numVertexes; ++i)
	{
		if (!visited[i])						//该棵树没有被访问
		{
			visited[i] = 1;						//根节点标记为访问，并输出，然后将其入队
			printf("%c ", G->vexs[i]);
			q.push(i);
			while (!q.empty())					//在队列非空的情况下进行处理
			{
				j = q.front();					//取出队首元素，并将其删除
				q.pop();
				for (k = 0; k < G->numVertexes; k++)		//访问该节点的孩子节点，并入队列
				{
					if (0 != G->arc[j][k] && G->arc[j][k] < INFINITY && !visited[k])
					{
						visited[k] = 1;
						printf("%c ", G->vexs[k]);
						q.push(k);
					}
				}
			}
			printf("\n");
		}
	}
}

/*图的广度优先搜索，邻接表*/
void BFSGraphAdjListTraverse(GraphAdjList *GL)
{
	int i, j;
	EdgeNode *e;
	queue<int> q;

	for (i = 0; i < GL->numVertexes; ++i)
		visited[i] = 0;
	
	printf("图的广度优先搜索:\n");
	for (i = 0; i < GL->numVertexes; ++i)
	{
		if (0 == visited[i])
		{
			visited[i] = 1;
			printf("%c ", GL->adjList[i].data);
			q.push(i);

			while (!q.empty())
			{
				/*取得队首元素，并将其删除*/
				j = q.front();
				q.pop();
				
				e = GL->adjList[j].firstEdge;
				while (e)
				{
					if (0 == visited[e->adjvex])
					{
						visited[e->adjvex] = 1;
						printf("%c ", GL->adjList[e->adjvex].data);
						q.push(e->adjvex);
					}
					e = e->next;
				}
			}
			printf("\n");
		}
	}
}





int main()
{
	MGraph G;
	GraphAdjList GL;
	/*CreateMGraph(&G);
	DFSMGraphTraverse(&G);
	BFSMGraphTraverse(&G);*/

	CreateGraphAdjList(&GL);
	DFSGraphAdjListTraverse(&GL);
	BFSGraphAdjListTraverse(&GL);
	return 0;
}