图:建立邻接表和深度和广度遍历

typedef char VertexType;
typedef int EdgeType;

#define MAXVEX 100

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
typedef struct EdgeNode
{
	int adjvex;	
	struct EdgeNode* next;
}EdgeNode;

typedef struct VertexNode
{

	char data;
	EdgeNode* firstedge;
}VertexNode;

typedef struct
{
	VertexNode adjlist[MAXVEX];
	int numNodes, numEdges;
}GraphAdjList;


void CreatALGraph(GraphAdjList* G)
{

	int i, j, k;
	EdgeNode* e;
	printf("输入顶点数和边数:\n");
	scanf(" %d %d", &G->numNodes, &G->numEdges);
	printf("请输入你的顶点\n");

	for (i = 0; i < G->numNodes; i++)
	{            
		//缓冲区的问题,所以这里必须加上空格后再使用%c
		scanf(" %c", & 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);
		//这是对i处的节点的操作
		e = (EdgeNode*)malloc(sizeof(EdgeNode));
		if (!e)
		{
			return;
		}
		e->adjvex = j;
		e->next = G->adjlist[i].firstedge;
		G->adjlist[i].firstedge = e;


		e = (EdgeNode*)malloc(sizeof(EdgeNode));
		if (!e)
		{
			return;
		}
		e->adjvex = i;
		e->next = G->adjlist[j].firstedge;
		G->adjlist[j].firstedge = e;
	}

}

bool visited[MAXVEX];

void DFS(GraphAdjList GL, int i)
{
	EdgeNode* p;
	visited[i] = true;
	printf(" %c", GL.adjlist[i].data);
	p = GL.adjlist[i].firstedge;
	while (p != NULL)
	{
		if (p == NULL)
		{
			break;
		}

		if (visited[p->adjvex] == false)
		{
			DFS(GL, p->adjvex);
		}
		p = p->next;
	}
	

}
//深度优先遍历操作
void DFStraverse(GraphAdjList GL)
{
	int i;
	for (i = 0; i < GL.numNodes; i++)
		visited[i] = false;
	
	for (i = 0; i < GL.numNodes; i++)
	{
		if (!visited[i]) 
		DFS(GL, i);
	}
}

//接下来是为广度优先做一个铺垫,这里是队列
#define MAXSIZE 100
typedef struct Queue
{
	int data[MAXSIZE];
	int front,rear;
	int size;
}Queue;

void  InitQueue(Queue* Q)
{ 
	Q->front = 0;
	Q->rear = 0;
	Q->size = 0;
}


//返回真表示队列为空,返回FALSE表示队列不为空
bool QueueEmpty(Queue *Q)
{
	if (Q->size == 0)
		return true;
	return false;
}

void EnQueue(Queue *Q,int value)
{

	//判断队列中是否为满
	if (Q->size == MAXSIZE)
	{
		printf("Queue is full\n");
		exit(EXIT_FAILURE);
	}

	Q->data[Q->rear] = value;
	Q->rear = (Q->rear + 1) % MAXSIZE;	
	Q->size++;
}

void OutQueue(Queue* Q,int *i)
{
	if (Q->size == 0)
	{
		printf("Queue is empty\n");
		exit(EXIT_FAILURE);
	}
	*i = Q->data[Q->front];
	Q->front = (Q->front + 1) % MAXSIZE;
	Q->size--;
	
}


//广度优先遍历
void BFSTtraverse(GraphAdjList GL)
{
	int i;
	EdgeNode* p;
	Queue Q;
	for (i = 0; i < GL.numNodes; i++)
	{
		visited[i] = false;
	}
	InitQueue(&Q);
	for (i = 0; i < GL.numNodes; i++)
	{
		if (!visited[i])
		{
			visited[i] = true;
			printf("%c", GL.adjlist[i].data);
			EnQueue(&Q, i);
			while (!QueueEmpty(&Q))
			{
				int temp;
				 OutQueue(&Q,&temp);
				 i = temp;
				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;
				}
			}
		}
	}
}




void test01()
{
	GraphAdjList G;

	CreatALGraph(&G);

	//DFStraverse(G);
	BFSTtraverse(G);
}

int main()
{
	
	test01();
	return 0;
}