无向图——基本操作

 1. 无向图的基本操作
 

// An highlighted block
/*
无向图--邻接矩阵表示
*/
#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 60
#define datatype char
struct MGraph
{
    datatype Vex[MAXSIZE];
    int Edge[MAXSIZE][MAXSIZE];
    int vexnum,arcnum;
    /* data */
};
struct Queue            //用于广度优先搜索
{
    int data[MAXSIZE];
    int rear;
    int front;
    /* data */
};

void InitGraph(MGraph &G);                                          //初始化邻接矩阵
void CreateGraph(MGraph &G);                                        //创建邻接矩阵
bool IsVexExist(MGraph G,datatype v1,datatype v2,int flag[]);       //判断当前输入的顶点是否存在
void ShowGraph(MGraph G);              //展示邻接矩阵
void BeforeBFS(MGraph G);                    //广度优先搜索
void InitQueue(Queue &queue);           //初始化队列
void EnQueue(Queue &queue,int flag);    //入队
int ExQueue(Queue &queue);             //出队
int GetIndexOfStart(MGraph G,datatype start);  //获取开始节点的下标
void BFS(MGraph G,Queue &queue,int mark[]);       //广度优先搜索
void DFS(MGraph G,int v,int mark[]);
void BeforeDFS(MGraph G);

int ExQueue(Queue &queue){
    if(queue.front>queue.rear)
        return -1;
    return queue.data[queue.front++];
}
void EnQueue(Queue &queue,int flag){
    if(queue.rear==MAXSIZE-1)
        return;
    queue.data[queue.rear++] = flag;
}
void InitQueue(Queue &queue){
    queue.front = queue.rear = 0;
}

void InitGraph(MGraph &G){          //初始化图

    for(int i = 0;i<MAXSIZE;i++){
        for (int j = 0; j < MAXSIZE; j++)
        {
            G.Edge[i][j] = 0;
            /* code */
        }
    }
    G.vexnum = 0;
    G.arcnum = 0;
}
bool IsVexExist(MGraph G,datatype v1,datatype v2,int flag[]){      //判断当前输入的两个顶点是否存在
    bool IV1 = false,IV2 = false;
    int f = 0;
    for(int i = 0;i<G.vexnum;i++){
        if(G.Vex[i] == v1)
        {
            IV1 = true;
            flag[f++] = i;
        }
        if(G.Vex[i] == v2)
        {
            IV2 = true;
            flag[f++] = i;
        }
    }
    return IV1&&IV2;
}
void CreateGraph(MGraph &G){        //创建图

    int Vexnum,Arcnum;
    printf("------Undirected Graph------\n");
    printf("Please Input the number of Vex and Edge: ");
    scanf("%d %d",&Vexnum,&Arcnum);
    getchar();
    if(Vexnum>MAXSIZE||Arcnum>(Vexnum-1)*Vexnum)        //请勿超过最大范围
    {
        printf("Maximum value exceeded, please try again\n");
        CreateGraph(G);
        return; 
    }
        
    for(int i =0;i<Vexnum;i++){             //获取顶点信息
        printf("Please Input %d-th Vex : ",(i+1));
        scanf("%c",&G.Vex[i]);
        getchar();
        G.vexnum++;
    }
    for(int i = 0;i < Arcnum; i++){         //获取边的信息

        datatype v1,v2;
        int weight;
        printf("Please Input %d-th Edge : ",(i+1));
        scanf("%c %c %d",&v1,&v2,&weight);
        getchar();
        if(v1==v2){
            printf("Input Error,Please Try Again!\n");
            i--;
            continue;
        }
        int flag[2];
        if(IsVexExist(G,v1,v2,flag))            //如果输出的两个定点都存在
        {
            G.Edge[flag[0]][flag[1]] = weight;
            G.Edge[flag[1]][flag[0]] = weight;
            G.arcnum++;
        }
        else{
            printf("The Vex You Input is not Existed,Please Input Again!\n");
            i--;
        }
    }
    ShowGraph(G);
}
void ShowGraph(MGraph G){

    printf("\nAdjacent Matrix : \n ");
    for (int i = 0; i < G.vexnum; i++)
    {
        printf("  %c",G.Vex[i]);
        /* code */
    }
    printf("\n");
    for(int i =0;i<G.vexnum;i++){
        printf("%c  ",G.Vex[i]);
        for (int j = 0; j < G.vexnum; j++)
        {
            printf("%d  ",G.Edge[i][j]);
            /* code */
        }
        printf("\n");
    }
}
void BeforeBFS(MGraph G){

    datatype Start;
    printf("Please Input Start-Vex : ");
    scanf("%c",&Start);
    getchar();
    int flag;
    if((flag = GetIndexOfStart(G,Start))==-1){          //检查开始顶点是否存在
        printf("Input Error,The Vex doesn't Exist,Please Try Again\n");
        BeforeBFS(G);
        return;
    }
    Queue queue;
    InitQueue(queue);
    int mark[MAXSIZE];
    for(int i = 0;i<G.vexnum;i++){
        mark[i] = 0;                            //表示没有被访问过
    }
    printf("BFS: ");
    EnQueue(queue,flag);
    BFS(G,queue,mark);                          //先访问根节点
    for(int i = 0;i<G.vexnum;i++){
        if(mark[i] == 0)                        //如果没有被访问
        {
            EnQueue(queue,i);
            BFS(G,queue,mark);
        }
    }
}
void BFS(MGraph G,Queue &queue,int mark[]){
    while(queue.front<queue.rear){
        int fl = ExQueue(queue);
        if(mark[fl] == 1)
            continue;
        printf("%c ",G.Vex[fl]);            //输出当前顶点
        mark[fl] =1;
        for(int i = 0;i<G.vexnum;i++){
            if(G.Edge[fl][i] == 1)
                EnQueue(queue,i);
        }
    }
}
int GetIndexOfStart(MGraph G,datatype start){       //得到标记的索引
    int flag = -1;
    for (int i = 0; i < G.vexnum; i++)
    {
        if(G.Vex[i] == start)
            flag = i;
        /* code */
    }
    return flag;
}
void BeforeDFS(MGraph G){           //DFS遍历

    datatype start;
    printf("\nPlease Input Start-Vex : ");
    scanf("%c",&start);
    getchar();
    int flag = GetIndexOfStart(G,start);
    if(flag == -1){

        printf("Input Error,The Vex doesn't Exist,Please Try Again\n");
        BeforeDFS(G);
        return;
    }
    int mark[MAXSIZE];
    for (int i = 0; i < G.vexnum; i++)
        mark[i] = 0;
    DFS(G,flag,mark);
    for (int i = 0; i < G.vexnum; i++)
        if(mark[i]==0)
            DFS(G,i,mark);
}
void DFS(MGraph G,int v,int mark[]){
    printf("%c ",G.Vex[v]);
    mark[v] = 1;
    for(int i = 0;i<G.vexnum;i++){
        if(mark[i]==0)
            DFS(G,i,mark);
    }
}
int main(){

    MGraph G;
    InitGraph(G);
    CreateGraph(G);
    BeforeBFS(G);
    BeforeDFS(G);
    system("pause");
    return 0;        
}