图的存储结构与操作--C语言实现

图（graph）是一种比树结构还要复杂的数据结构，它的术语，存储方式，遍历方式，用途都比较广，所以如果想要一次性完成所有的代码，那代码会非常长。所以，我将分两次来完成图的代码。这一次，我会完成图的五种存储结构的创建（邻接矩阵存储，邻接表存储，十字链表存储，邻接多重表存储，边集数组存储），两种遍历方式（深度优先遍历，广度优先遍历）。与树结构一样，图结构的遍历也需要借助队列来协助实现。

#include<stdio.h>
#include<malloc.h>
typedef char VertexType;        //顶点类型
typedef int EdgeType;            //权值类型
#define MAXVEX 100                //最大顶点数
#define INFINITY 65535            //无限大
#define TURE 1
#define FALSE 0
typedef int Boolean;  10 Boolean visited[MAXVEX];            //记录访问过的结点数组

#define MAXSIZE 100                            //队列最大空间
typedef int QElemType;                        //队列中元素类型
typedef int Status;                            //返回值类型
#define OK 1                                //操作成功
#define ERROR 0                                //操作失败

typedef struct                                //队列结点结构
{  20     QElemType date[MAXSIZE];                //结点元素
    int front;                                //队头
    int rear;                                //队尾
}SqQueue;  24 
/*队列的初始化*/
Status InitQue(SqQueue *Q)  27 {  28     Q->front = 0;                            //队头指向0
    Q->rear = 0;                            //队尾指向0
    return OK;  31 }  32 
/*队列的入队操作*/
Status EnQueue(SqQueue *Q, QElemType e)  35 {  36     if((Q->rear + 1) % MAXSIZE == Q->front)                //判断队列是否已满
        return ERROR;  38     Q->date[Q->rear] = e;                                //队尾赋值为e
    Q->rear = (Q->rear + 1) % MAXSIZE;                    //队尾后移
    return OK;  41 }  42 
/*队列的出队操作*/
Status DeQueue(SqQueue *Q, QElemType *e)  45 {  46     if(Q->front == Q->rear)                                //判断队列是否为空
        return ERROR;  48     *e = Q->date[Q->front];                                //将队头元素取出
    Q->front = (Q->front + 1) % MAXSIZE;                //队头后移
    return OK;  51 }  52 
/*获取队列的长度*/
int LengthQue(SqQueue Q)  55 {  56     return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;  57 }  58 
//邻接矩阵结构体
typedef struct                    
{  62     VertexType adList[MAXVEX];            //声明顶点数组
    EdgeType arc[MAXVEX][MAXVEX];        //声明权值数组
    int numVerexes,numEdges;            //顶点数，边数
}Graph;  66 
//邻接表结构体
typedef struct EdgeNode                //边表结构体
{  70     int adjSub;                        //存储边表的下标  71 // EdgeType weight; //权重
    struct EdgeNode *next;            //指向下一个相邻顶点的指针
}EdgeNode;  74 
typedef struct VertexNode            //顶点结构体
{  77     VertexType date;                //顶点内容
    EdgeNode *firstEdge;            //指向顶点第一个邻接点
}GraphList[MAXVEX];  80 
typedef struct                        //邻接表结构体
{  83     GraphList graphList;            //顶点数组
    int numVerexes, numEdges;        //顶点数，边数
}AjaGraph;  86 
//十字链表结构体
typedef struct Orthogonal            //边表结构体
{  90     int tailVex;                    //当前顶点下标
    int headVex;                    //弧尾顶点下标
    struct Orthogonal *tailLink;    //指向入度弧的弧尾
    struct Orthogonal *headLink;    //指向出度弧的弧头
}Orthogonal;  95 
typedef struct                        //顶点结构体
{  98     VertexType date;                //顶点内容
    Orthogonal *firstin;            //指向第一个弧头为自己的点
    Orthogonal *firstout;            //指向第一个弧尾为自己的点
}Orthogonal_Node[MAXVEX]; 102 
typedef struct
{ 105     Orthogonal_Node orth_Node;        //声明结点数组
    int numVertexes,numEdges;        //顶点数量，边数量
}OrthGraph;                            //十字链表图结构 108 
//边集数组结构体
typedef struct                        //边结构体
{ 112     int iVex;                        //顶点位置
    int jVex;                        //顶点位置
    EdgeType weight;                //权重
}EdgeArray[MAXVEX]; 116 
typedef struct                        //图结构体
{ 119     VertexType VexterList[MAXVEX];    //顶点数组
    EdgeArray EdgeList;                //边数组
    int numVexteres, numEdges;        //顶点数量，边数量
}EdgeListArray;                        //边集数组图结构 123 
//邻接多重表
typedef struct EdgeList_multiple            //边表结点
{ 127     int iVex;                                    //当前顶点下标
    int jVex;                                    //终点下表
    struct EdgeList_multiple *iLink;                    //指向与顶点i有相同起点的结点
    struct EdgeList_multiple *jLink;                    //指向与顶点j有相同终点的结点
}EdgeList_multiple; 132 
typedef struct
{ 135     VertexType date;                        //顶点数据
    EdgeList_multiple *firstEdge;            //指向顶点的第一个邻接点
}Vexs; 138 
typedef struct
{ 141     Vexs vexs[MAXVEX];                                //建立顶点数组
    int numVexes;                            //顶点数量
    int numEdges;                            //边的数量
}MultipleGraph; 145 
//邻接多重表创建图结构
int CreatGraphMultiple(MultipleGraph *G) 148 { 149     int i,j,k; 150     printf("请输入顶点数i与边的数量j："); 151     scanf("%d,%d",&G->numVexes,&G->numEdges); 152     EdgeList_multiple *em; 153  getchar(); 154     for(i = 0; i < G->numVexes; i++) 155  { 156         printf("请输入第%d个顶点：",i); 157         scanf("%c", &G->vexs[i].date); 158  getchar(); 159  } 160     for(k = 0; k < G->numEdges; k++) 161  { 162         printf("请输入边的起点i与终点j的下标："); 163         scanf("%d,%d",&i,&j); 164         em = (EdgeList_multiple *)malloc(sizeof(EdgeList_multiple));        //创建新结点空间
        em->iVex = i; 166         em->jVex = j; 167         em->iLink = G->vexs[i].firstEdge; 168         G->vexs[i].firstEdge = em; 169         em->jLink = G->vexs[j].firstEdge; 170         G->vexs[j].firstEdge = em; 171  } 172     return 1; 173 } 174 
//邻接矩阵创建图结构
int CreatGraph(Graph *G) 177 { 178     int i,j,k,w; 179     printf("请输入结点数i,边数j:"); 180     scanf("%d,%d",&G->numVerexes,&G->numEdges);        //写入顶点数和边数
    for(i = 0; i < G->numVerexes; i++)                    //初始化顶点数组
 { 183         printf("请输入第%d个顶点：",i); 184         scanf("%c",&G->adList[i]); 185  getchar(); 186  } 187     for(i = 0; i < G->numVerexes; i++)                    //初始化权值矩阵
        for(j = 0; j < G->numVerexes; j++) 189             G->arc[i][j] = INFINITY; 190     for(k = 0; k<G->numEdges; k++)                        //写入权值
 { 192         printf("请输入需要添加权值的下标i和下标j,及其权值w："); 193         scanf("%d,%d,%d", &i, &j, &w); 194         G->arc[i][j] = w; 195         G->arc[j][i] = G->arc[i][j];                    //无向图的对称性
 } 197     return 1; 198 } 199 
//邻接表创建图结构
int CreatAjaGraph(AjaGraph *G) 202 { 203     int i, j, k; 204     char a; 205     EdgeNode *e;                                //声明边表新结点
    printf("请输入顶点i和边数j："); 207     scanf("%d, %d", &G->numVerexes, &G->numEdges);        //写入顶点数与边数
 getchar(); 209     for(i = 0; i < G->numVerexes; i++)                    //初始化顶点数组
 { 211         printf("请输入第%d个结点：",i); 212         scanf("%c",&G->graphList[i].date); 213  getchar(); 214         printf("%c\n", a); 215         G->graphList[i].firstEdge = NULL;                //顶点数组的指针域指向空
 } 217     for(k = 0; k < G->numEdges; k++)                    //构建边表
 { 219         printf("请输入邻接点Vi与Vj的下标："); 220         scanf("%d,%d", &i, &j); 221         e = (EdgeNode *)malloc(sizeof(EdgeNode));        //创建新结点空间
        e->adjSub = j;                                    //新结点的数据域为j
        e->next = G->graphList[i].firstEdge;            //新结点指针域指向顶点指针域
        G->graphList[i].firstEdge = e;                    //顶点指针域指向新结点

        e = (EdgeNode *)malloc(sizeof(EdgeNode));        //因为是无向图
        e->adjSub = i;                                    //同时为i操作
        e->next = G->graphList[j].firstEdge; 229         G->graphList[j].firstEdge = e; 230  } 231     
    return 1; 233 } 234 
//十字链表结构创建图结构
int CreatOrthGraph(OrthGraph *G) 237 { 238     int i,j,k; 239     Orthogonal *e; 240     printf("请输入顶点数量i和边数量j："); 241     scanf("%d,%d", &G->numVertexes, &G->numEdges);        //写入顶点数和边数
    for(i = 0; i < G->numVertexes; i++)                    //对顶点数组初始化
 { 244         printf("请输入第%d个结点：",i); 245         scanf("%c",&G->orth_Node[i].date);                    //输入顶点内容
 getchar(); 247         G->orth_Node[i].firstin = NULL;                    //将入边表指向空
        G->orth_Node[i].firstout = NULL;                //将出边表指向空
 } 250     for(k = 0; k < G->numEdges; k++)                    //构建边表
 { 252         printf("请输入起点i与终点j的下标："); 253         scanf("%d,%d", &i, &j); 254         e = (Orthogonal *)malloc(sizeof(Orthogonal));    //创建新结点空间
        e->tailVex = i;                                    //当前结点等于i
        e->headVex = j;                                    //弧尾等于j
        e->tailLink = G->orth_Node[i].firstout;            //入度指针等于顶点入度指针
        G->orth_Node[i].firstout = e;                    //顶点位置i的firstout指向e 
        e->headLink = G->orth_Node[j].firstin;            //出度指针等于顶点出度指针 
        G->orth_Node[j].firstin = e;                    //顶点位置j的firstout指向e
 } 262     return 1; 263 } 264 
//边集数组创建图结构
int CreatGraph(EdgeListArray *G) 267 { 268     int i, j, w; 269     printf("请输入顶点数量i与边的数量j："); 270     scanf("%d,%d", &G->numVexteres, &G->numEdges);        //写入顶点数量与边数量
    for(i = 0; i < G->numVexteres; i++)                    //构建顶点数组
 { 273         printf("请输入第%d个结点：",i); 274         scanf("%c",&G->VexterList[i]); 275  } 276     for(i = 0; i < G->numEdges; i++)                    //构建边数组
 { 278         printf("请输入顶点i与顶点j及其权重w："); 279         scanf("%d,%d", &i, &j, &w); 280         G->EdgeList[i].iVex = i;                        //这里的i只是边数组的下标，与顶点数组无关
        G->EdgeList[i].jVex = j; 282         G->EdgeList[i].weight = w; 283  } 284     return 1; 285 } 286 
//遍历邻接矩阵结构
void PrintfGraph(Graph G) 289 { 290     int i,j; 291     for(i = 0; i < G.numVerexes; i++) 292         for(j = 0; j < G.numVerexes; j++) 293             if(G.arc[i][j] != INFINITY && i < j) 294                 printf("顶点： %d ， %d, 权重： %d\n", i, j, G.arc[i][j]); 295 } 296 
//邻接表深度优先遍历
void PrintDeepthAjaGraph(AjaGraph G, int i)            //递归函数
{ 300     visited[i] = TURE;                                //将此顶点记为访问过
    printf("%c\n", G.graphList[i].date);            //打印当前顶点
    EdgeNode *ag;                                    //创建顶点指针
    ag = G.graphList[i].firstEdge;                    //将此指针赋值为当前顶点的边表第一个结点
    while(ag)                                        //只要ag不为空
 { 306         if(!visited[ag->adjSub])                    //如果当前边表第一个结点不为空
            PrintDeepthAjaGraph(G, ag->adjSub);        //递归
        ag = ag->next;                                //否则ag赋值为ag的下一临结点
 } 310 } 311 
void Depth_first(AjaGraph G)                //深度优先遍历函数
{ 314     int j; 315     for(j = 0; j < G.numVerexes; j++)        //初始化记录数组
        visited[j] = FALSE; 317     for(j = 0; j < G.numVerexes; j++)        //遍历顶点数组中的每一个顶点
 { 319 // printf("当前结点是：%d, 其是否遍历过 %d\n", j, visited[j]);
        if(!visited[j])                        //如果当前结点没被访问过
            PrintDeepthAjaGraph(G, j);        //调用递归函数
 } 323 } 324 
//邻接表广度优先搜索
void BFs(AjaGraph G) 327 { 328     int j; 329     SqQueue Q;            //创建队Q
    InitQue(&Q);        //初始化队列
    for(j = 0; j < G.numVerexes; j++)            //初始化记录数组
        visited[j] = FALSE; 333     EdgeNode *ag;                                //创建边表指针
    visited[0] = TURE;                            //将第一个顶点记为访问过
    printf("%c\n", G.graphList[0].date);        //打印第一个顶点
    EnQueue(&Q, 0);                                //将第一个顶点入队
    while(Q.front != Q.rear)                    //只要队列不为空
 { 339         DeQueue(&Q, &j);                        //将当前顶点出队
        ag = G.graphList[j].firstEdge;            //ag赋值为当前结点的第一个边表结点
        while(ag && !visited[ag->adjSub])        //ag不为空且ag未被访问过
 { 343             visited[ag->adjSub] = TURE;            //将ag记为访问过
            printf("%c\n", G.graphList[ag->adjSub].date);    //打印ag
            EnQueue(&Q, ag->adjSub);            //将ag入队
            ag = ag->next;                        //ag赋值为ag的下一邻接表结点
 } 348  } 349 } 350 
void main() 352 { 353  Graph G1; 354  AjaGraph G2; 355  OrthGraph G3; 356  MultipleGraph G4; 357  EdgeListArray G5; 358     while(true) 359  { 360         int flag = 0; 361         printf("请选择对图的操作：\n"); 362         printf("1.邻接矩阵存储创建\n"); 363         printf("2.邻接表存储创建\n"); 364         printf("3.十字链表存储创建\n"); 365         printf("4.邻接多重表创建\n"); 366         printf("5.边集数组创建\n"); 367         printf("6.遍历邻接矩阵图结构\n"); 368         printf("7.邻接表深度优先遍历\n"); 369         printf("8.遍历线索化二叉树\n"); 370         printf("9.退出\n"); 371         int a; 372         scanf("%d", &a); 373         switch(a) 374  { 375             case 1: 376                 flag = 0; 377                 flag = CreatGraph(&G1); 378                 if(flag) 379                     printf("创建成功\n"); 380                 else
                    printf("创建失败\n"); 382                 break; 383             case 2: 384                 flag = 0; 385                 flag = CreatAjaGraph(&G2); 386                 if(flag) 387                     printf("创建成功\n"); 388                 else
                    printf("创建失败\n"); 390                 break; 391             case 3: 392                 flag = 0; 393                 flag = CreatOrthGraph(&G3); 394                 if(flag) 395                     printf("创建成功\n"); 396                 else
                    printf("创建失败\n"); 398                 break; 399             case 4: 400                 flag = 0; 401                 flag = CreatGraphMultiple(&G4); 402                 if(flag) 403                     printf("创建成功\n"); 404                 else
                    printf("创建失败\n"); 406                 break; 407             case 5: 408                 flag = 0; 409                 CreatGraph(&G5); 410                 if(flag) 411                     printf("创建成功\n"); 412                 else
                    printf("创建失败\n"); 414                 break; 415             case 6: 416  PrintfGraph(G1); 417                 break; 418             case 7: 419  Depth_first(G2); 420                 break; 421             case 8: 422  BFs(G2); 423                 break; 424             case 9: 425                 return; 426             default: 427                 printf("选择错误\n"); 428                 break; 429  } 430  } 431 }