图由有穷、非空点集和边集合组成，简写成G(V,E0)

图的创建有多种方法（邻接矩阵、邻接表、十字链表）

图的遍历方法（深度优先遍历、广度优先遍历）

此篇博客为一道算法题，博中代码实现了邻接矩阵创建有向图，分别使用深度优先和广度优先遍历图，并且计算图中每个节点的出度与入度。

题目：

从键盘接收图的顶点集，关系集，创建有向图。
第一行依次输入图的顶点个数n，关系个数k，以空格隔开。顶点个数<=20
第二行依次输入顶点值，类型为字符。
接下去有k行，每行为两个字符 u 和 v，表示节点u 和 v 连通。格式为【uv】,中间不用空格间隔。
计算结点的出度和入度，并输出，共n行。格式为【顶点w 出度值 入度值】，三者用空格间隔。
接下去的一行，从A顶点出发，进行深度优先遍历，并输出，结点不间隔。
最后一行，从A顶点出发，进行广度优先遍历，并输出，结点不间隔。

代码：

/*
图的邻接矩阵
*/

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAX 20

int visited[MAX] = {0};

typedef struct {
    char vex[MAX];
    int arcs[MAX][MAX];
    int vexnum , arcnum ;
}Chart ,* ChartNode;

typedef struct qnode{
    int node;
    struct qnode * pNext;
}Qnode;

typedef struct linkq{
    Qnode * front;
    Qnode * rear;
}LinkQ;


//初始化队列 
int InitQueue(LinkQ * LQ){
    LQ->front = LQ->rear = (Qnode *)malloc(sizeof(Qnode));
    LQ->front->pNext = LQ->rear->pNext = NULL;
    LQ->front->node = LQ->rear->node = 0;
    return 0;
}

//入队 
int EnQueue(LinkQ * LQ , int i){
    Qnode * qd = (Qnode *)malloc(sizeof(Qnode));
    qd->pNext = NULL;
    qd->node = i;
    LQ->rear->pNext = qd;
    LQ->rear = qd;
}

//出队 
int DeQueue(LinkQ * LQ){
    int i;
    Qnode * qd = NULL;
    qd = LQ->front->pNext;
    i = qd->node;
    LQ->front->pNext = LQ->front->pNext->pNext;
    free(qd);
    if(LQ->front->pNext == NULL){
         LQ->rear = LQ->front;
    }
    return i;
}

//判空 
int QueueEmpty(LinkQ * LQ){
    if(LQ->front == LQ->rear){
        return 0;
    }else{
        return 1;
    }
}

//初始化状态 
int Initvisited(){
    int i;
    for(i=0;i<MAX;i++){
        visited[i] = 0;
    }
    return 0;
}

//创建图 
ChartNode CreatChart(){
    ChartNode chart;
    char vex_1 , vex_2;
    int i;
    chart = (ChartNode)malloc(sizeof(Chart));
    memset(chart->arcs,0,sizeof(chart->arcs));
    scanf("%d %d",&chart->vexnum,&chart->arcnum);
    //fflush(stdin);
    scanf("%s",chart->vex);
   // fflush(stdin);
    for(i=0;i<chart->arcnum;i++){
        getchar(); 
        scanf("%c%c",&vex_1,&vex_2);
       // fflush(stdin);
        chart->arcs[vex_1-65][vex_2-65] = 1;
    }
    return chart;
}

//深度优先遍历 
int DFS(ChartNode chart , int i){
    
    int j;
    visited[i] = 1;
    printf("%c",chart->vex[i]);
    for(j = 0;j<chart->vexnum;j++){
        if(chart->arcs[i][j]==1&&!visited[j]){
            DFS(chart,j);
        }
    }   
    return 0;
    
}

//广度优先遍历 
int DFST(ChartNode chart , LinkQ * LQ){
    int i,j;
    Initvisited();
    InitQueue(LQ);
    for(i=0;i<chart->vexnum;i++){
        
        if(!visited[i]){
            visited[i] = 1;
            printf("%c",chart->vex[i]);
            EnQueue(LQ,i);
            
            while(QueueEmpty(LQ)){
                i = DeQueue(LQ);
                for(j = 0;j<chart->vexnum;j++){
                    if(chart->arcs[i][j] == 1 && !visited[j]){
                        visited[j] = 1;
                        printf("%c",chart->vex[j]);
                        EnQueue(LQ,j);
                    }
                }
            }
        }
    }   
}

//计算节点出入度
int Degrees(ChartNode chart){
    int i,j;
    int in = 0,out = 0;
    
    for(i = 0;i<chart->vexnum;i++){
        for(j = 0;j<chart->vexnum;j++){
            if(chart->arcs[i][j] == 1){
                out++;
            }
            if(chart->arcs[j][i] == 1){
                in++;
            }
        }
        printf("%c %d %d\n",chart->vex[i],out,in);
        in = 0;
        out = 0;
    }
}


int main(){
    
    ChartNode chart = NULL;
    LinkQ LQ;
    int i,j;
    chart = CreatChart();   
    Initvisited();
    Degrees(chart);
    DFS(chart,0);
    printf("\n");   
    DFST(chart , &LQ);
    return 0;
}