邻接表与邻接矩阵构造部分

邻接矩阵

#include<stdio.h>
#include<stdlib.h>
#include<limits.h>

#define OK 1
#define ERROR 0
#define INFINITY INT_MAX // 整数最大值
#define MAX_VERTEX_NUM 20 // 最大顶点个数
#define DG 1 // 有向图
#define DN 2 // 有向网
#define UDG 3 // 无向图
#define UDN 4 // 无向网

typedef int GraphKind;
typedef int VRType; // 顶点关系类型
typedef char VertexType; // 顶点向量类型
// typedef enum {DG, DN, UDG, UDN} GraphKind; // {有向图，有向网，无向图，无向网}
typedef struct ArcCell {
    VRType adj; // 对无权图，用1或0表示相邻否；对带权图，则为权值类型。
    
}ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef struct {
    VertexType vexs[MAX_VERTEX_NUM]; // 顶点向量
    AdjMatrix arcs; // 邻接矩阵
    int vexnum; // 图的当前顶点数
    int arcnum; // 图的当前弧数
    GraphKind kind; // 图的种类标志
}MGraph;


/* 确定顶点在G中的位置*/
int LocateVex(MGraph G, VertexType v) {
    int m = 0;
    while(v != G.vexs[m]){
        m++;
    }
    return m;
}

/* 采用邻接矩阵构造无向网G */
int CreateUDN(MGraph *G) {
    VertexType v1, v2;
    VRType w;
    int i, j, k;
    scanf("%d%d",&(G->vexnum), &(G->arcnum));
    for(i = 0; i < G->vexnum; i++) scanf(&G->vexs[i]); // 构造顶点向量
    for(i = 0; i < G->vexnum; i++)
        for(j = 0; j < G->vexnum; j++)
            G->arcs[i][j].adj = INFINITY; // 初始化邻接矩阵
    for(k = 0; k < G->arcnum; k++) {
        scanf(&v1, &v2, &w);
        i = LocateVex(*G, v1);
        j = LocateVex(*G, v2);
        G->arcs[i][j].adj = w;
        G->arcs[i][j] = G->arcs[i][j];
    }
    return OK;
}

/* 采用邻接矩阵构造无向图G */
int CreateUDG(MGraph *G) {
    VertexType v1, v2;
    VRType w;
    int i, j, k;
    scanf("%d%d",&G->vexnum, &G->arcnum);
    for(i = 0; i < G->vexnum; i++) scanf("%c",&G->vexs[i]); // 构造顶点向量
    for(i = 0; i < G->vexnum; i++)
        for(j = 0; j < G->vexnum; j++)
            G->arcs[i][j].adj = 0; // 初始化邻接矩阵
    for(k = 0; k < G->arcnum; k++) {
        scanf(&v1, &v2, &w);
        i = LocateVex(*G, v1);
        j = LocateVex(*G, v2);
        G->arcs[i][j].adj = w;
        G->arcs[i][j] = G->arcs[i][j];
    }
    return OK;
}

/* 采用邻接矩阵构造有向网G */
int CreateDN(MGraph *G) {
    VertexType v1, v2;
    VRType w;
    int i, j, k;
    scanf("%d%d",&G->vexnum, &G->arcnum);
    for(i = 0; i < G->vexnum; i++) scanf(&G->vexs[i]); // 构造顶点向量
    for(i = 0; i < G->vexnum; i++)
        for(j = 0; j < G->vexnum; j++)
            G->arcs[i][j].adj = INFINITY; // 初始化邻接矩阵
    for(k = 0; k < G->arcnum; k++) {
        scanf(&v1, &v2, &w);
        i = LocateVex(*G, v1);
        j = LocateVex(*G, v2);
        G->arcs[i][j].adj = w;
    }
    return OK;
}

/* 采用邻接矩阵构造有向图G */
int CreateDG(MGraph *G) {
    VertexType v1, v2;
    VRType w;
    int i, j, k;
    scanf("%d%d",&G->vexnum, &G->arcnum);
    for(i = 0; i < G->vexnum; i++) scanf(&G->vexs[i]); // 构造顶点向量
    for(i = 0; i < G->vexnum; i++)
        for(j = 0; j < G->vexnum; j++)
            G->arcs[i][j].adj = 0; // 初始化邻接矩阵
    for(k = 0; k < G->arcnum; k++) {
        scanf(&v1, &v2, &w);
        i = LocateVex(*G, v1);
        j = LocateVex(*G, v2);
        G->arcs[i][j].adj = w;
    }
    return OK;
}

/* 采用邻接矩阵构造图G*/
int CreateGraph(MGraph *G) {
    scanf("%d", &((*G).kind));
    switch((*G).kind) {
        case DG: return CreateDG(G); // 构造有向图G
        case DN: return CreateDN(G); // 构造有向网G
        case UDG: return CreateUDG(G); // 构造无向图G
        case UDN: return CreateUDN(G); // 构造无向网G
        default: return ERROR;
    }
} // CreateGraph

int main(){
    MGraph G;
    CreateGraph(&G);
    return 0;
}

邻接表

#include<stdio.h>
#include<stdlib.h>
#include<limits.h>


#define OK 1
#define ERROR 0
#define MAX_VERTEX_NUM 20
#define DG 1 // 有向图
#define DN 2 // 有向网
#define UDG 3 // 无向图
#define UDN 4 // 无向网

typedef char VertexType;
typedef struct ArcNode {
    int adjvex; // 该弧所指向的顶点的位置
    int weight; // 边的权值
    struct ArcNode *nextarc; // 指向下一条弧的指针
}ArcNode, *Arc;

typedef struct VNode {
    VertexType data; // 顶点信息
    ArcNode *firstarc; // 指向第一条依附该顶点的弧的指针
}VNode, AdjList[MAX_VERTEX_NUM];
typedef struct {
    AdjList vertices;
    int vexnum; // 图的当前顶点数
    int arcnum; // 图的当前弧数
    int kind; // 图的种类标志
}ALGraph;

int CreateALGraph(ALGraph *G) {
    int i, j, k;
    ArcNode *e;
    scanf("%d%d",&G->vexnum,&G->arcnum); // 输入顶点数和边数
    // 读入顶点信息,建立顶点表
    for(i = 0;i < G->vexnum;i++){
        scanf(&G->vertices[i].data); // 输入顶点信息
        G->vertices[i].firstarc = NULL; // 将边表置为空表
    }
    
    for(k = 0;k < G->vexnum;k++)/* 建立边表 */
    {
        scanf("%d%d",&i,&j); // 输入边(vi,vj)上的顶点序号
        e = (ArcNode *)malloc(sizeof(ArcNode)); // 向内存申请空间,生成边表结点
        e->adjvex = j;    // 邻接序号为j
        e->nextarc = G->vertices[i].firstarc;    // 将e的指针指向当前顶点上指向的结点
        G->vertices[i].firstarc = e;    // 将当前顶点的指针指向

        e = (ArcNode *)malloc(sizeof(ArcNode)); // 向内存申请空间,生成边表结点
        e->adjvex = i;    // 邻接序号为i
        e->nextarc = G->vertices[j].firstarc;    // 将e的指针指向当前顶点上指向的结点
        G->vertices[j].firstarc = e;    // 将当前顶点的指针指向e
    }
}


int main(){
    ALGraph G;
    CreateALGraph(&G);
    return 0;
}