无向图遍历（广度、深度）

昨天偷懒，今天发无向图的遍历。明天英语并不是很慌，虽然没怎么复习= =，可能这就是废柴大学生的淡定吧。

#include<stdio.h>
#include<stdlib.h>
#define Max 20
bool visited[Max];
//邻接矩阵
typedef struct {
	char vexs[Max];
	int arc[Max][Max];//邻接矩阵
	int vexnum, arcnum;//顶点数和边数
}MGraph;
//队列

typedef struct QNode {
	int data;
	struct QNode *next;
}QNode,*QueuePtr;

typedef struct {
	QueuePtr front, rear;
}LinkQueue;

int initQueue(LinkQueue *q) {
	q->front = q->rear = (QueuePtr)malloc(sizeof(QNode));
	if (!q->front) {
		return 0;
	}
	q->front->next = NULL;
	return 1;
}

int EnQueue(LinkQueue *q, int e) {
	QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
	if (!s) {
		return 0;
	}
	s->data = e;
	s->next = NULL;
	q->rear->next = s;
	q->rear = s;
	return 1;

}
int DeQueue(LinkQueue *q, int *e) {
	QueuePtr p;
	if (q->front == q->rear) {
		return 0;
	}
	p = q->front->next;
	*e = p->data;
	q->front->next = p->next;
	if (q->rear == p) {
		q->rear = q->front;
	}
	free(p);
	return 1;
}
int QueueEmpty(LinkQueue q) {
	if (q.front == q.rear) {
		return 1;
	}
	return 0;
}



//返回顶点所在的位置
int Locatevex(MGraph G,char c) {
	for (int i = 0; i < G.vexnum; i++) {
		if (c == G.vexs[i]) {
			return i;
		}
	}
}

void CreateMGraph(MGraph *G) {
	printf("请输入顶点数和边数:\n");
	scanf_s("%d%d", &G->vexnum, &G->arcnum);
	
	printf("输入顶点名称:\n");
	for (int i = 0; i < G->vexnum; i++) {
		getchar();
		scanf_s("%c", &G->vexs[i]);
	}
	for (int i = 0; i < G->vexnum; i++) {
		for (int j = 0; j < G->vexnum; j++) {
			G->arc[i][j] = 0;
		}
	}
	for (int m = 0; m < G->arcnum; m++) {
		char a, b;
		int i, j;
		
		printf("输入边:\n");
		getchar();
		scanf_s("%c",&a);
		getchar();
		scanf_s("%c", &b);
		i = Locatevex(*G, a);
		j = Locatevex(*G, b);
		G->arc[i][j]= 1;
		G->arc[j][i] = 1;
	}
}


void DFS(MGraph G, int i) {
	visited[i] = true;
	printf("%c", G.vexs[i]);
	for (int j = 0; j < G.vexnum; j++) {
		if (G.arc[i][j] == 1 && !visited[j]) {
			DFS(G, j);
		}
	}
}

void DFSTraverse(MGraph G) {
	for (int i = 0; i < G.vexnum; i++) {
		visited[i] = false;
	}
	for (int j = 0; j < G.vexnum; j++) {
		if (!visited[j]) {
			DFS(G, j);
		}
	}
}

void BFSTraverse(MGraph G) {
	LinkQueue Q;
	for (int i = 0; i < G.vexnum; i++) {
		visited[i] = false;
	}
	initQueue(&Q);
	for (int i = 0; i < G.vexnum; i++) {
		if (!visited[i]) {
			visited[i] = true;
			printf("%c", G.vexs[i]);
			EnQueue(&Q, i);
		}
		while (!QueueEmpty(Q)) {
			DeQueue(&Q, &i);
			for (int j = 0; j < G.vexnum; j++) {
				if (G.arc[i][j] == 1 && !visited[j]) {
					visited[j] = true;
					printf("%c", G.vexs[j]);
					EnQueue(&Q, j);
				}
			}
		}

	}
}


//邻接表
//边表节点
typedef struct EdgeNode {
	int adjvex;
struct EdgeNode *next;
}EdgeNode;

//顶点表节点
typedef struct VertexNode {
	char data;
	EdgeNode *first;
}VertexNode,AdjList[Max];

typedef struct {
	AdjList adjList;
	int vexnum, arcnum;//顶点数和边数
}graphAdjList,*GraphAdjList;
//构建邻接表
void CreateALGraph(MGraph G, GraphAdjList *GL)
{
	EdgeNode *e;

	*GL = (GraphAdjList)malloc(sizeof(graphAdjList));

	(*GL)->vexnum = G.vexnum;
	(*GL)->arcnum = G.arcnum;

	for (int i = 0; i<G.vexnum; i++)
	{
		(*GL)->adjList[i].data = G.vexs[i];
		(*GL)->adjList[i].first = NULL;
	}
	for (int k = 0; k<G.vexnum; k++)
	{
		for (int j = 0; j<G.vexnum; j++)
		{
			if (G.arc[k][j] == 1)
			{
				e = (EdgeNode *)malloc(sizeof(EdgeNode));
				e->adjvex = j;
				e->next = (*GL)->adjList[k].first;
				(*GL)->adjList[k].first = e;
			}
		}
	}
}
//邻接表的深度优先递归算法
void DFS(GraphAdjList GL, int i)
{
	EdgeNode *p;
	visited[i] = true;
	printf("%c ", GL->adjList[i].data);
	p = GL->adjList[i].first;
	while (p)
	{
		if (!visited[p->adjvex])
		{
			DFS(GL, p->adjvex);
		}
		p = p->next;
	
	}
}

//邻接表的深度遍历操作
void DFSTraverse(GraphAdjList GL)
{
	int i;
	for (i = 0; i<GL->vexnum; i++)
		visited[i] = false;//初始化
	for (i = 0; i<GL->vexnum; i++)
		if (!visited[i])
			DFS(GL, i);
}


//邻接表的广度遍历算法
void BFSTraverse(GraphAdjList GL)
{
	EdgeNode *p;
	LinkQueue Q;
	for (int i = 0; i < GL->vexnum; i++)
	{
		visited[i] = false;
	}
	initQueue(&Q);
	for (int i = 0; i < GL->vexnum; 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].first;
				while (p)
				{
					if (!visited[p->adjvex])
					{
						visited[p->adjvex] = true;
						printf("%c ", GL->adjList[p->adjvex].data);
						EnQueue(&Q, p->adjvex);
					}
					p = p->next;
				}
			}
		}
	}
}
int main() {
	
	MGraph G;
	GraphAdjList GL;
	CreateMGraph(&G);
	CreateALGraph(G, &GL);
	printf("深度优先搜索:\n");
	DFSTraverse(GL);
	printf("\n");
	printf("广度优先搜索:\n");
	BFSTraverse(GL);
	return 0;
	/*
	MGraph G;
	CreateMGraph(&G);
	DFSTraverse(G);
	printf("\n");
	BFSTraverse(G);
	return 0;
	*/
}