C语言建立有向图的邻接矩阵及其遍历操作

/*C语言建立有向图的邻接矩阵及其遍历操作*/
#include"stdio.h"
#include"stdlib.h"
//图的邻接矩阵储存结构
typedef char elemtype;
#define maxsize 10
#define queuesize 100  
typedef struct{
    elemtype vex[maxsize];//顶点表
    int arc[maxsize][maxsize];//邻接矩阵
    int n,e;//边数，顶点数
}graph;
//在图中查找顶点v,存在返回其在顶点数组中的下标，不存在返回-1
int locatevex(graph g,elemtype v)
{
    int i;
    for(i=0;i<g.n;i++)if(g.vex[i]==v)return i;
    return -1;
}
//打印信息
void print(graph g)
{
    int i,j;
    printf("图的邻接矩阵表示：\n");
    for(i=0;i<g.n;i++){
        for(j=0;j<g.n;j++){
            printf("%3d",g.arc[i][j]);
        }
        printf("\n");
    }
}
//创建有向图的邻接矩阵
void creategraph(graph *g){
    int i,j,k;
    elemtype v1,v2;
    printf("请输入顶点数和边数：\n");
    printf("顶点数n=");scanf("%d",&g->n);
    printf("边  数e=");scanf("%d",&g->e);
    printf("请输入图的顶点信息：\n");
    getchar();
    for(i=0;i<=g->n;i++)
    scanf("%c",&g->vex[i]);
    for(i=0;i<g->n;i++)
        for(j=0;j<g->n;j++)
            g->arc[i][j]=0;//初始化邻接矩阵
    printf("请输入图的边的信息：\n");
    for(k=0;k<g->e;k++)
    {
        printf("请输入第%d条边的两个端点：",k+1);
        scanf("%c%c",&v1,&v2);
        fflush(stdin);//清空输入缓冲区
        i=locatevex(*g,v1);j=locatevex(*g,v2);
        if(i>=0&&j>=0){
        g->arc[i][j]=1;
        g->arc[j][i]=1;//无向网矩阵对称
        }
    }
}
int DFSvisited[maxsize];/* 访问标志数组*/
 /*从第i个顶点出发递归地深度优先遍历图G*/
void DFS(graph g,int i)
{
    int j;
    printf("%3c",g.vex[i]); /*访问第i个项点*/
    DFSvisited[i]=1;
    for(j=0;j<g.n;j++)
    {
        if((g.arc[i][j]==1)&&(DFSvisited[j]==0))
            DFS(g,j);/* //对i的尚未访问的邻接顶点j递归调用DFS */
    }
}
//对图g进行深度优先遍历
void DFStraverse(graph g) 
{
    int v;
    for (v=0; v<g.n;v++)DFSvisited[v]=0; /*初始化标志数组*/
    for  (v=0; v<g.n;v++) /*保证非连通图的遍历,连通图只执行一次*/
/*从第v个顶点出发递归地深度优先遍历图G*/
        if (!DFSvisited[v]) DFS(g,v);        
}
//循环队列存储结构定义
typedef struct  cirqueue
{
    elemtype  *data;      //队列存储空间的首地址
    int front;         //队头位置：指向当前队头元素
    int rear;    //队尾位置：指向当前队尾元素的下一位置
}cirqueue;             // 循环队列
//构造空队，如果成功，返回1，如果失败，返回0
int initqueue(cirqueue *q)
{
    q->data=(elemtype *)malloc(queuesize*sizeof(cirqueue));
    if (q->data==NULL)return 0; // 存储分配失败 
    q->front=q->rear=0;    
    return 1;
 }
// 插入元素e为Q的新的队尾元素 ,如果成功，返回1，如果失败，返回0
int enqueue (cirqueue *q,elemtype e)
{ 
    if ((q->rear+1) % queuesize == q->front) 
        return 0; //队列满
    q->data[q->rear] = e;
    q->rear = (q->rear+1) % queuesize; //队尾后移一位
    return 1;
}
//若队列不空，则删除Q的队头元素，用e返回其值,并返回1；否则返回0
int dequeue (cirqueue *q,int *e) 
{
    if (q->front == q->rear)  return 0; //队列为空
    *e = q->data[q->front];
    q->front = (q->front+1) %queuesize; //队头后移一位
    return 1;
}
//若栈不空，则用e返回队头元素,并返回1；否则返回0
int getfront(cirqueue q,elemtype *e)
{
    if (q.front == q.rear)  return 0; //队列为空
    *e=q.data[q.front];
    return  1;
 }
//若队列为空栈，则返回1，否则返回0 
int queueempty(cirqueue q)//栈非空
{ 
    if(q.front == q.rear)return 1; //队列为空
    else return 0;
}
//返回队列的元素个数，即队列的长度
int queuelength(cirqueue q)
{ 
    return (q.rear-q.front+queuesize) % queuesize;
}
//【算法6-10：利用邻接矩阵实现连通图的广度优先搜索遍历】
int BFSvisited[maxsize];
cirqueue q;
/*从第k个顶点出发广度优先遍历图G,G以邻接矩阵表示。*/
void BFS(graph g,int i){
    int j;    
    initqueue(&q);/*初始化队列*/
    printf("%3c",g.vex[i]);/*访问第k个顶点*/
    BFSvisited[i]=1;
    enqueue(&q,i);/*第k个顶点进队*/
    while(queueempty(q)==0) {/*队列非空*/
        dequeue(&q,&i);
        for(j=0;j<g.n;j++){
           if((g.arc[i][j]==1)&&(BFSvisited[j]==0)){
/*访问第i个顶点的末曾访问的顶点j*/
                printf("%3c",g.vex[j]);
                BFSvisited[j]=1;
                enqueue(&q,j);/*第k个顶点进队*/
            }
        }
    }
}
//【算法6-11：对图G进行广度优先遍历】
void BFStraverse(graph  g) //对图G进行广度优先遍历
{
    int v;
    for (v=0; v<g.n;v++) //初始化标志数组
        BFSvisited[v]=0; 
    for  (v=0; v<g.n;v++) //保证非连通图的遍历
        if (!BFSvisited[v])BFS(g,v); 
       //从第v个顶点出发递归地广度优先遍历图G
}
int main()
{
    graph g;
    creategraph(&g);
    print(g);
    printf("\n");
    printf("图的深度优先遍历序列：\n");
    DFStraverse(g);
    printf("\n");
    printf("图的广度优先遍历序列：\n");
    BFStraverse(g);
    printf("\n");
    return 0;
}