/*******************************************************************************
*																			   *
*					图（邻接矩阵存储）的深度优先和广度优先					   *
*																			   *
*******************************************************************************/
#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];
    }
}