/*******************************************************************************
*																			   *
*					图（邻接矩阵存储）的深度优先和广度优先					   *
*																			   *
*******************************************************************************/
#include<iostream>
#define MaxVertexNum  30
using namespace std;
bool visited[MaxVertexNum];

typedef int VertexType;
typedef int Edgetype;
typedef struct{
	VertexType vertexs[MaxVertexNum];
	Edgetype arcs[MaxVertexNum][MaxVertexNum];
	int vertexNum,edgeNum;
}MGraph;

typedef int DataType;
typedef struct{				/*队列*/
	DataType data[MaxVertexNum];//数据域
	int front,rear;//队头和队尾指针
}SeqQueue,* PSeqQueue;

void Create_MGraph(MGraph * G);				/*创建图*/
void DFStraverse(MGraph * G);				/*深度优先*/
void DFS(MGraph * G,int v);					/*深度优先搜索算法*/
void BFStraverse(MGraph * G);				/*广度优先*/
void BFS(MGraph * G,int v);					/*广度优先搜索算法*/

PSeqQueue Init_SeqQueue(void);				/*循环队列初始化*/
int Empty_SeqQueue(PSeqQueue Q);			/*判断队空*/
void In_SeqQueue(PSeqQueue Q,DataType x);	/*入队*/
void Out_SeqQueue(PSeqQueue Q,DataType * y);/*出队*/

int main(){
	cout<<"创建图：";
	MGraph * G=(MGraph *)malloc(sizeof(MGraph));
	Create_MGraph(G);

	cout<<"\n深度优先遍历（图）：";
	DFStraverse(G);
	cout<<"\b\b";
	cout<<"\n广度优先遍历（图）：";
	BFStraverse(G);
	cout<<"\b\b";

	return 0;
}

/*创建图*/
void Create_MGraph(MGraph * G){
	int i,j,k;

	cout<<"请输入图的顶点数和边数：";
	cin>>G->vertexNum>>G->edgeNum;
	cout<<"输入"<<G->vertexNum<<"个顶点的表示形式：";
	for(i=0;i<G->vertexNum;i++)
		cin>>G->vertexs[i];		/*顶点是字符还是数字*/

	for(i=0;i<G->vertexNum;i++){
		for(j=0;j<G->vertexNum;j++){
			G->arcs[i][j]=0;
		}
	}
	VertexType v1,v2;
	for(k=0;k<G->edgeNum;k++){
		cout<<"读入边(Vi,Vj)起点和终点对应的序号：";
		cin>>v1>>v2;
		for(i=0;v1!=G->vertexs[i];i++);
		for(j=0;v2!=G->vertexs[j];j++);
		G->arcs[i][j]=1;
		G->arcs[j][i]=1;
	}
}

/*深度优先搜索算法*/
void DFS(MGraph * G,int v){
	cout<<G->vertexs[v]<<"->";
	visited[v]=true;/*访问第v个顶点，并把访问标志置true*/

	for(int w=0;w<G->vertexNum;w++){
		if(G->arcs[v][w]==1 && !visited[w])/*对v尚未访问的邻接顶点w入队列Q*/
			DFS(G,w);
	}
}

/*深度优先*/
void DFStraverse(MGraph * G){
	int v;
	for(v=0;v<G->vertexNum;v++)
		visited[v]=false;
	for(v=0;v<G->vertexNum;v++){
		if(!visited[v])
			DFS(G,v);
	}
}

void BFStraverse(MGraph * G){
	int v;
	for(v=0;v<G->vertexNum;v++)
		visited[v]=false;
	for(v=0;v<G->vertexNum;v++){
		if(!visited[v])
			BFS(G,v);
	}
}

void BFS(MGraph * G,int v){
	int u,w;

	cout<<G->vertexs[v]<<"->";
	visited[v]=true;/*访问第v个顶点，并把访问标志置true*/
	PSeqQueue Q=Init_SeqQueue();
	In_SeqQueue(Q,v);

	while(!Empty_SeqQueue(Q)){
		Out_SeqQueue(Q,&u);
		for(w=0;w<G->vertexNum;w++){
			if(G->arcs[u][w]==1 && !visited[w]){/*对v尚未访问的邻接顶点w入队列Q*/
				cout<<G->vertexs[w]<<"->";
				visited[w]=true;
				In_SeqQueue(Q,w);
			}
		}
	}
}

/*循环队列初始化*/
PSeqQueue Init_SeqQueue(void){
	PSeqQueue Q;
	Q=(PSeqQueue)malloc(sizeof(SeqQueue));
	if(Q){
		Q->front=0;
		Q->rear=0;
	}
	return Q;
}

/*判断队空*/
int Empty_SeqQueue(PSeqQueue Q){
	if(Q && Q->front==Q->rear)
		return 1;
	else 
		return 0;
}

/*入队*/
void In_SeqQueue(PSeqQueue Q,DataType x){
	if(Q->front == (Q->rear+1)%MaxVertexNum){
		cout<<"队满不能入队！";
		return;
	}else{
		Q->rear=(Q->rear+1)%MaxVertexNum;
		Q->data[Q->rear]=x;
	}
}

/*出队*/
void Out_SeqQueue(PSeqQueue Q,DataType * y){
	if(Empty_SeqQueue(Q)){
		cout<<"队空不能出队！";
		return;
	}else{
		Q->front=(Q->front+1)%MaxVertexNum;
		* y=Q->data[Q->front];
	}
}