图的相关操作（邻接表表示法）

最新推荐文章于 2022-11-13 18:58:56 发布
最新推荐文章于 2022-11-13 18:58:56 发布
阅读量470 收藏
点赞数 1
分类专栏： 考研数据结构 文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43288447/article/details/122269924
版权

图的相关操作（邻接表表示法）

文章目录

一：邻接表的结构：

#define MAX_VERTEX_NUM 20   //定义最大顶点的数量
#define InfoType int     //图中弧或者是边的数据类型
typedef enum{DG,UDG}GraphKind;       //0-有向图，1-无向图
typedef int VetexType_Al;   //图中的顶点数据类型

/*
 * 表结点
 */
typedef struct ArcNode{
    int adjvex;             //顶点的序号
    struct ArcNode* nextarc;    //指向下一条弧的指针
    InfoType info;          //该弧的信息
}ArcNode;

/*
 * 头结点
 */
typedef struct VNode{
    VetexType_Al data;      //顶点信息
    ArcNode* firstarc;
}VNode;
typedef VNode AdjList[MAX_VERTEX_NUM];  //存放头信息的数组

/*
 * 图的邻接表存储表示
 */
typedef struct {
    AdjList vertices;   //头信息的数组
    int vexnum,arcnum;  //图中顶点的数量和边的数量
 //   int IncInfo;        //InInfo为0，则表示图中各弧不含其他信息
    GraphKind kind;     //图的种类
}ALGraph;

二：构造有向图与无向图的入口函数

/**
 * 创造函数的入口函数
 * @param G
 * @return
 */
int CreatGraph_AL(ALGraph* G){
    printf("Please input the kind of G:");
    scanf("%d",&G->kind);
    switch (G->kind) {
        case DG:
            return CreatDG_AL(G);
        case UDG:
            return CreatUDG_AL(G);
        default:break;
    }
    return 1;
}

三：构造有向图

//创建有向图
int CreatDG_AL(ALGraph* G){
    ArcNode* r[MAX_VERTEX_NUM];     //用作访问标记，用来定位
    ArcNode* p;                     //需要插入的结点

    printf("Please input the num of vex and arc:");
    scanf("%d,%d",&(G->vexnum),&(G->arcnum));
    getchar();

    //初始化数据
    printf("Please input the data of vex:\n");
    for (int i = 0; i < G->vexnum; ++i) {
        scanf("%d",&(G->vertices[i].data));
        getchar();
        G->vertices[i].firstarc = NULL;
        r[i] = NULL;
    }

    int v1,v2;
    //读取各边，开始制作邻接表
    for (int i = 0; i < G->arcnum; ++i) {
        printf("Please input the trail and head:");
        scanf("%d,%d",&v1,&v2);
        getchar();

        //这里的头和尾指的是，弧头的顶点和弧尾的顶点
        int trail = LocateVex_AL(*G,v1);
        int head = LocateVex_AL(*G,v2);

        //判断图中是否含有顶点
        if (head==-1||trail==-1){
            return 0;
        }
        //制作结点
        p = (ArcNode*)malloc(sizeof (ArcNode));
        if (!p){
            exit(0);    //分配内存失败
        }
        p->adjvex = head;
        p->nextarc = NULL;
        if (r[trail] == NULL){
            G->vertices[trail].firstarc = p;
        } else{
            r[trail]->nextarc = p;
        }
        r[trail] = p;
    }
    return 1;
}

四：构造无向图

//创建无向图
int CreatUDG_AL(ALGraph* G){
    ArcNode* r[MAX_VERTEX_NUM];
    ArcNode* p;
    ArcNode* q;

    printf("Please input the num of vex and arc:");
    scanf("%d,%d",&(G->vexnum),&(G->arcnum));
    getchar();

    //初始化
    for (int i = 0; i < G->vexnum; ++i) {
        printf("Please input the data of vex:");
        scanf("%d,%d",&(G->vertices[i].data));
        getchar();
        G->vertices [i].firstarc = NULL;
        r[i] = NULL;
    }

    int v1,v2;
    for (int i = 0; i < G->arcnum; ++i) {
        printf("Please input the trail and head:");
        scanf("%d,%d",&v1,&v2);
        getchar();

        //在无向图中就没有严格的弧的头尾概念，这里只是做一个区别而已
        int trail = LocateVex_AL(*G,v1);
        int head = LocateVex_AL(*G,v2);

        if (head == -1 || trail == -1 ){
            return 0;
        }

        //制作结点
        p = (ArcNode*)malloc(sizeof (ArcNode));
        if (!p){
            exit(0);
        }
        p->adjvex = head;
        p->nextarc = NULL;
        if (r[trail] == NULL){
            G->vertices[trail].firstarc = p;
        } else{
            r[trail]->nextarc = p;
        }
        r[trail] = p;

        q = (ArcNode*)malloc(sizeof (ArcNode));
        if (!q){
            exit(0);
        }
        q->adjvex = trail;
        q->nextarc = NULL;
        if (r[head] == NULL){
            G->vertices[head].firstarc = q;
        } else{
            r[head]->nextarc = q;
        }
        r[head] = q;
    }
    return 1;
}

五：获取顶点在数组中的下标

/**
 * 定位顶点在顶点数组中的位置，返回下标
 * @param G
 * @param v
 * @return      返回顶点在顶点数组中位置，下标,否则返回-1
 */
int LocateVex_AL(ALGraph G,VetexType_Al v){
    for (int i = 0; i < G.vexnum; ++i) {
        if (G.vertices[i].data == v){
            return i;
        }
    }
    return -1;
}

六:获取指定结点的第一个相邻顶点的下标值

/**
 * 获取与给定顶点的第一个相邻顶点在顶点数组中的下标
 * @param G
 * @param v
 * @return	返回顶点在顶点数组中的下标
 */
int FirstAdjVex_AL(ALGraph G,VetexType_Al v){
    int index = LocateVex_AL(G,v);
    if (index!=-1 && G.vertices[index].firstarc){
        return G.vertices[index].firstarc->adjvex;
    }
    return -1;
}

七：获取顶点v相对顶点w的下一个顶点的下标值

/**
 * 获取顶点v相对于顶点w的下一个邻接顶点，返回顶点在顶点数组中下标
 * @param G
 * @param v
 * @param w
 * @return
 */
int NextAdjVex_AL(ALGraph G,VetexType_Al v,VetexType_Al w){
    int indexv = LocateVex_AL(G,v);
    int indexw = LocateVex_AL(G,w);
    ArcNode* p;     //用来循环的指针
    if (indexv!=-1 && indexw!=-1 && G.vertices[indexv].firstarc){
        p = G.vertices[indexv].firstarc;
        while (p){
            if (p->adjvex == indexw){
                if (p->nextarc){
                    return p->nextarc->adjvex;
                } else{
                    return -1;
                }
            } else{
                p = p->nextarc;
            }
        }
    } else{
        return -1;
    }
    return -1;
}

八：深度优先遍历算法

/**
*使用邻接表和邻接矩阵表示的图，深度优先遍历的算法基本上没有改变，只是需要注意对于顶点数据的表示
*/

void visitVexAL(ALGraph G,int index){
    printf("%d\t",G.vertices[index].data);
}

//全局变量
bool visited[MAX_VERTEX_NUM];

//深度优先遍历算法
void DFSTraverse_AL(ALGraph G){
    //初始化访问变量
    for (int i = 0; i < G.vexnum; ++i) {
        visited[i] = false;
    }
    for (int i = 0; i < G.vexnum; ++i) {
        if (!visited[i]){   //没有被访问
            DFS_AL(G,i);
        }
    }

}
//深度优先遍历核心算法
void DFS_AL(ALGraph G,int indexv){

    visited[indexv] = true;
    visitVexAL(G,indexv);

    int w;
    //递归
    for (w = FirstAdjVex_AL(G,G.vertices[indexv].data);w>=0;
    w = NextAdjVex_AL(G,G.vertices[indexv].data,G.vertices[w].data)) {
        if (!visited[w]){
            DFS_AL(G,w);
        }
    }
}

九：广度优先遍历算法

/**
 * 广度优先遍历，使用数组来模拟队列的操作
 * 类似于二叉树的层次遍历
 * 邻接矩阵和邻接表的广度优先遍历算法基本一样，同样也只是需要注意对于顶点数据的表示
 * @param G
 */
void BFSTraverse_AL(ALGraph G){

    //对访问标志数组进行初始化操作
    for (int i = 0; i < G.vexnum; ++i) {
        visited[i] = false;
    }

    //用数组来模拟队列
    VetexType_Al queue[20];
    int top = 0;    //头
    int rear = 0;   //尾

    for (int i = 0; i < G.vexnum; ++i) {
        if (!visited[i]){   //如果没有别访问
            visited[i] = true;
            visitVexAL(G,i);    //访问

            //进队列中
            queue[rear] = G.vertices[i].data;
            rear = (rear+1)%20;
            while (rear-top != 0){      //队列非空时
                VetexType_Al v = queue[top];
                top = (top+1)%20;
                for (int w = FirstAdjVex_AL(G,v); w >=0 ; w = NextAdjVex_AL(G,v,G.vertices[w].data)) {
                    if (!visited[w]){
                        visited[w] = true;
                        visitVexAL(G,w);
                        queue[rear] = G.vertices[w].data;
                        rear = (rear+1)%20;
                    }
                }
            }
        }
    }
}

在这里插入图片描述

啥也不会的研究牲
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构--图的邻接表基本操作
花有重开日，人无再少年。
05-22 1098
图的邻接表基本操作 代码如下： #include<stdio.h> #include<string.h> #include<stdlib.h> #include<malloc.h> #define MAX_VERTEX_NUM 20 #define MAX_NAME 3 #define Status int #define ERROR 1 #define OK 0 typedef char VertexType[MAX_NAME]; typedef int I
数据结构之图的邻接表的基本操作
qq_28397005的博客
05-02 4442
邻接表 邻接表是图的一种顺序存储与链式存储相结合的存储方式。对于图G中的每个顶点Vi，将所有邻接于Vi的顶点Vj链接成一个单链表，这个单链表称为顶点Vi的邻接表，再将所有的邻接表表头放到数组中，就构成了图的邻接表 邻接表中有两种结点结构，第一种包含一个数据域和一个指针域，作顶点结点；另一种是做边结点，第一个数据域存放与Vi邻接的结点，第二个数据域存放结点信息或者权值等，然后就是指针域
图的基本操作
m0_64005495的博客
11-13 514
【代码】图的基本操作。
C++实现有向图的邻接表表示
12-20
在邻接表表示法中，有向图的每个顶点都有一个链表，链表中的每个节点代表与该顶点相连的其他顶点，即邻接顶点。 【邻接表的优势】 相比于邻接矩阵，邻接表在处理稀疏图时更为高效，因为它只存储实际存在的边，而不...
邻接链表法实现图C代码
02-27
本文将详细讲解如何使用邻接链表法来实现图，并介绍上述描述中的各项操作。 1. **创建图**：创建图通常涉及到定义节点（Vertex）和边（Edge）的数据结构。节点可以存储一个标识符（如整数或字符串），而边则存储...
数据结构无向图邻接表表示和DFS遍历
12-01
数据结构无向图DFS遍历，通过DFS来实现无向图的邻接表实现
图的邻接表表示法 pdf
04-03
图的邻接表表示法: 1.邻接表的结点结构 2.无向图的邻接表 3.有向图的邻接表 4.有向图的逆邻接表 5.邻接表的形式说明及其建表算法 6.图的两种存储结构比较
图的四种表示方法(邻接表, 邻接矩阵, 十字链表, 邻接多重表).cpp
05-12
学习数据结构和离散数学的同学, 这是我的理解和相关代码
图——邻接矩阵的存储与基本操作
75 69 69 80 32 67 79 68 73 78 71 33
03-14 6488
1.邻接表存储 用两个数组分别存储：数据元素（顶点）的信息和数据元素之间的关系（边或弧）的信息。 其形式描述如下： // ----- 图的数组（邻接矩阵）存储表示 ----- // // 常量定义 # define INFINITY -1 // 最大权重，表示不邻接关系 # define MAX_VERTEX_NUM 10 // 最大顶点个数 typedef int...
[数据结构与算法] 图
m0_47652477的博客
04-18 1533
第六章 图 6.1 图的定义和基本术语 图： G=（V,E） Graph = (Vertex, Edge) V: 顶点(数据元素)的有穷非空集合 E: 边的有穷集合 完全图: 任意两个点都有一条边相连 稀疏图: 有很少边或弧的图(e < nlongn) 稠密图: 有较多边或弧的图 网: 边/弧带权的图 邻接: 有边/弧相连的两个顶点之间的关系 存在(vi,vj).则称这两个点互为邻接点 存在<vi,vj>,则称vi邻接到vj,vj邻接于vi 关联(依附): 边/弧与顶点之间
图的基本操作【严蔚敏】
MooMLu的博客
04-27 3585
图的基本操作：ADT Graph{ 数据对象V：V是具有相同特性的数据元素的集合，称为顶点集。 数据关系R：R={VR} VR={<v,w>|v,w∈V且P(v,w)，<v,w>表示从v到w的弧， 谓词P(v,w)定义了弧<v,w>的意义或信息} 基本操作： CreateGraph( &G, V, VR ) 初始条件：V是图的顶
图的邻接表表示方法
weixin_30244681的博客
10-24 107
1 #include<stdio.h> 2 #include<stdlib.h> 3 #include<time.h> 4 #define OK 1 5 #define NO 0 6 #define TRUE 1 7 #define FALSE 0 8 #define ERROR -1 9 #define ...
图的邻接矩阵表示及其基本操作
热门推荐
hellolde的博客
08-21 1万+
图的邻接矩阵表示及其基本操作 文章目录图的邻接矩阵表示及其基本操作1.邻接矩阵 1.邻接矩阵 表示图的一种简单方式是使用二维数组，称为邻接矩阵表示法。图中的每条边(v, w)，设置A[v][w]=1；若不存在边(v, w)，则A[v][w] = 0；如果边上带权值，那么可以设置A[v][w]等于该权值，同时使用一个很大或者很小的权值来表示不存在的边。如图，展示了无向图、有向图、有向网和它们的邻接矩阵。 邻接矩阵是一种顺序结构，从邻接矩阵的行数或者列数可知图的顶点数。无向图的邻接矩阵总是对称的，但有向图的邻
图的邻接表表示法c++
最新发布
03-23
邻接表是一种图的表示方法，它使用链表来存储每个节点的邻居节点。在C语言中，可以使用结构体和指针来实现邻接表。以下是一个示例代码： ``` #include <stdio.h> #include <stdlib.h> // 邻接表节点结构体 typedef struct AdjListNode { int dest; struct AdjListNode* next; } AdjListNode; // 邻接表头结构体 typedef struct AdjList { AdjListNode* head; } AdjList; // 图结构体 typedef struct Graph { int V; AdjList* array; } Graph; // 创建邻接表节点 AdjListNode* newAdjListNode(int dest) { AdjListNode* newNode = (AdjListNode*)malloc(sizeof(AdjListNode)); newNode->dest = dest; newNode->next = NULL; return newNode; } // 创建图 Graph* createGraph(int V) { Graph* graph = (Graph*)malloc(sizeof(Graph)); graph->V = V; graph->array = (AdjList*)malloc(V * sizeof(AdjList)); for (int i = 0; i < V; i++) { graph->array[i].head = NULL; } return graph; } // 添加边 void addEdge(Graph* graph, int src, int dest) { AdjListNode* newNode = newAdjListNode(dest); newNode->next = graph->array[src].head; graph->array[src].head = newNode; newNode = newAdjListNode(src); newNode->next = graph->array[dest].head; graph->array[dest].head = newNode; } // 打印邻接表 void printGraph(Graph* graph) { for (int i = 0; i < graph->V; i++) { AdjListNode* node = graph->array[i].head; printf("邻接表节点 %d 的邻居节点：", i); while (node) { printf("%d ", node->dest); node = node->next; } printf("\n"); } } int main() { Graph* graph = createGraph(5); addEdge(graph, 0, 1); addEdge(graph, 0, 4); addEdge(graph, 1, 2); addEdge(graph, 1, 3); addEdge(graph, 1, 4); addEdge(graph, 2, 3); addEdge(graph, 3, 4); printGraph(graph); return 0; } ``` 这段代码实现了一个无向图的邻接表表示法，可以通过调用 `createGraph` 函数创建一个具有 `V` 个节点的图，然后通过 `addEdge` 函数添加边，最后通过 `printGraph` 函数打印邻接表。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值