基于C语言的图的创建(邻接矩阵)和DFS,BFS

最新推荐文章于 2024-06-20 20:37:30 发布
最新推荐文章于 2024-06-20 20:37:30 发布
阅读量138 收藏 2
点赞数
文章标签： c语言 深度优先 宽度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43369883/article/details/130887454
版权

1.定义图的结构体

typedef struct Graph {
    char* vexs;//顶点的值 
    int** arcs;//边(二级指针,类似于二维数组) 
    int vexNum;//顶点数量 
    int arcNum;//边的数量 
}Graph;

2.定义队列结构体 

typedef struct Queue {//队列的结构体变量 
    int front;//头 
    int rear;//尾 
    int data[MAXSIZE];//队列元素 
}Queue;

 3.初始化队列 

Queue* initQueue() {
    Queue* Q = (Queue*)malloc(sizeof(Queue));
    Q->front = Q->rear = 0;
    return Q;
}

 4.判断队列是否为满

int isFull(Queue* Q) {
    if ((Q->rear + 1) % MAXSIZE == Q->front) {//队满 
        return 1;
    }
    else {
        return 0;
    }
}

5.判断队是否为空

int isEmpty(Queue* Q) {
    if (Q->front == Q->rear) {//队空 
        return 1;
    }
    else {
        return 0;
    }
}

 6.进队

int enQueue(Queue* Q, int data) {
    if (isFull(Q)) {
        return 0;
    }
    else {
        Q->data[Q->rear] = data;
        Q->rear = (Q->rear + 1) % MAXSIZE;
        return 1;
    }
}

7.出队

int deQueue(Queue* Q) {
    if(isEmpty(Q)) {
        return -1;
    }
    else {
        int data = Q->data[Q->front];
        Q->front = (Q->front + 1) % MAXSIZE;
        return data;
    }
}

 8.初始化图

Graph* initGraph(int vexNum) {
/*参数一:顶点的数量*/
	int i;
    Graph* G = (Graph*)malloc(sizeof(Graph));//开辟空间,把整个大图的空间开辟出来 
    G -> vexs = (char*)malloc(sizeof(char) * vexNum);//开辟顶点值的空间 
    G -> arcs = (int**)malloc(sizeof(int*) * vexNum);//开辟vexNum行空间存放边的指针 
    for (i = 0 ; i < vexNum; i++) {
        G -> arcs[i] = (int*)malloc(sizeof(int) * vexNum);//开辟每一行存放的边的内存 
    }
    G -> vexNum = vexNum;//图的顶点数
    G -> arcNum = 0;//图的边数初始化为0 
    return G;//返回图G 
}

9.创建邻接矩阵图

void createGraph(Graph* G, char* vexs, int* arcs) {
/*参数一:图的指针 
参数二:顶点
参数三:边*/
	int i,j;
    for (i = 0 ; i < G -> vexNum; i++) {
        G -> vexs[i] = vexs[i];//对图中的每个顶点赋值 
        for (j = 0; j < G -> vexNum; j++) {
        	/*对矩阵中每一行的各个点赋值*/
            G -> arcs[i][j] = *(arcs + i * G -> vexNum + j);//将arcs二维数组中的元素挨个写入 
            if (G -> arcs[i][j] != 0)//不等于0则代表两点之间有边 
                G -> arcNum ++;//边数加一 
        }
    }
    G -> arcNum /= 2;//矩阵中的边是真实图中的边的两倍,因此要除以2 
}

10.深度优先遍历

void DFS(Graph* G, int* visited, int index) {
	/*参数一:图
	参数二:外界标识数组,访问标记为1,不访问标记为0
	参数三:从那个结点开始访问*/
	int i;
    printf("%c\t", G -> vexs[index]);
    visited[index] = 1;//标记已经访问 
    for (i = 0; i < G ->vexNum; i++) {//挨个访问 
        if (G -> arcs[index][i] == 1 && !visited[i]) {//如果两点之间有边并且没有访问过 
            DFS(G, visited, i);//递归,访问下一个结点 
        }
    }
}

11.广度优先遍历

void BFS(Graph* G, int* visited, int index) {
	/*参数一:图
	参数二:标识图中的结点是否被访问过,0没访问,1被访问
	参数三:开始访问的结点位置*/
	int i,j;
    Queue* Q = initQueue();//初始化队列 
    printf("%c\t", G -> vexs[index]);//输出第一个 
    visited[index] = 1;//已经访问过置为1 
    enQueue(Q, index);//入队 
    while (!isEmpty(Q)) {//结束条件:队为空 
        int i = deQueue(Q);//出队 
        for (j = 0; j < G -> vexNum; j++) {//图中结点挨个访问 
            if (G -> arcs[i][j] == 1 && !visited[j]) {//如果两点之间有边并且没有访问过 
                printf("%c\t", G -> vexs[j]);
                visited[j] = 1;//访问过置为1 
                enQueue(Q, j);//入队 
            }
        }
    }
}

12.主函数

int main() {
    Graph* G = initGraph(5);//初始化图 
    int* visited = (int*)malloc(sizeof(int) * G -> vexNum);//申请新空间 
    int i;
    for (i = 0; i < G -> vexNum; i++)
        visited[i] = 0;//初始置为0,表明结点没有访问过 
    int arcs[5][5] = {
        0,1,1,1,0,
        1,0,1,1,1,
        1,1,0,0,0,
        1,1,0,0,1,
        0,1,0,1,0
    };
    createGraph(G, "ABCDE", (int*)arcs);//验证创立图(邻接矩阵) 
    DFS(G, visited, 0);//验证深度优先遍历 
    printf("\n");
    for (i = 0; i < G -> vexNum; i++)
        visited[i] = 0;
    BFS(G, visited, 0);
    printf("\n");
    return 0;
}

 完整代码:

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

#define MAXSIZE 5

typedef struct Graph {
    char* vexs;//顶点的值 
    int** arcs;//边(二级指针,类似于二维数组) 
    int vexNum;//顶点数量 
    int arcNum;//边的数量 
}Graph;

typedef struct Queue {//队列的结构体变量 
    int front;//头 
    int rear;//尾 
    int data[MAXSIZE];//队列元素 
}Queue;
/*初始化队列*/
Queue* initQueue() {
    Queue* Q = (Queue*)malloc(sizeof(Queue));
    Q->front = Q->rear = 0;
    return Q;
}
/*判断队列是否为满*/
int isFull(Queue* Q) {
    if ((Q->rear + 1) % MAXSIZE == Q->front) {//队满 
        return 1;
    }
    else {
        return 0;
    }
}
/*判断队是否为空*/
int isEmpty(Queue* Q) {
    if (Q->front == Q->rear) {//队空 
        return 1;
    }
    else {
        return 0;
    }
}
/*进队*/
int enQueue(Queue* Q, int data) {
    if (isFull(Q)) {
        return 0;
    }
    else {
        Q->data[Q->rear] = data;
        Q->rear = (Q->rear + 1) % MAXSIZE;
        return 1;
    }
}
/*出队*/
int deQueue(Queue* Q) {
    if(isEmpty(Q)) {
        return -1;
    }
    else {
        int data = Q->data[Q->front];
        Q->front = (Q->front + 1) % MAXSIZE;
        return data;
    }
}
/*初始化图*/
Graph* initGraph(int vexNum) {
/*参数一:顶点的数量*/
	int i;
    Graph* G = (Graph*)malloc(sizeof(Graph));//开辟空间,把整个大图的空间开辟出来 
    G -> vexs = (char*)malloc(sizeof(char) * vexNum);//开辟顶点值的空间 
    G -> arcs = (int**)malloc(sizeof(int*) * vexNum);//开辟vexNum行空间存放边的指针 
    for (i = 0 ; i < vexNum; i++) {
        G -> arcs[i] = (int*)malloc(sizeof(int) * vexNum);//开辟每一行存放的边的内存 
    }
    G -> vexNum = vexNum;//图的顶点数
    G -> arcNum = 0;//图的边数初始化为0 
    return G;//返回图G 
}
/*创建邻接矩阵图*/
void createGraph(Graph* G, char* vexs, int* arcs) {
/*参数一:图的指针 
参数二:顶点
参数三:边*/
	int i,j;
    for (i = 0 ; i < G -> vexNum; i++) {
        G -> vexs[i] = vexs[i];//对图中的每个顶点赋值 
        for (j = 0; j < G -> vexNum; j++) {
        	/*对矩阵中每一行的各个点赋值*/
            G -> arcs[i][j] = *(arcs + i * G -> vexNum + j);//将arcs二维数组中的元素挨个写入 
            if (G -> arcs[i][j] != 0)//不等于0则代表两点之间有边 
                G -> arcNum ++;//边数加一 
        }
    }
    G -> arcNum /= 2;//矩阵中的边是真实图中的边的两倍,因此要除以2 
}
/*深度优先遍历*/
void DFS(Graph* G, int* visited, int index) {
	/*参数一:图
	参数二:外界标识数组,访问标记为1,不访问标记为0
	参数三:从那个结点开始访问*/
	int i;
    printf("%c\t", G -> vexs[index]);
    visited[index] = 1;//标记已经访问 
    for (i = 0; i < G ->vexNum; i++) {//挨个访问 
        if (G -> arcs[index][i] == 1 && !visited[i]) {//如果两点之间有边并且没有访问过 
            DFS(G, visited, i);//递归,访问下一个结点 
        }
    }
}
/*广度优先遍历*/
void BFS(Graph* G, int* visited, int index) {
	/*参数一:图
	参数二:标识图中的结点是否被访问过,0没访问,1被访问
	参数三:开始访问的结点位置*/
	int i,j;
    Queue* Q = initQueue();//初始化队列 
    printf("%c\t", G -> vexs[index]);//输出第一个 
    visited[index] = 1;//已经访问过置为1 
    enQueue(Q, index);//入队 
    while (!isEmpty(Q)) {//结束条件:队为空 
        int i = deQueue(Q);//出队 
        for (j = 0; j < G -> vexNum; j++) {//图中结点挨个访问 
            if (G -> arcs[i][j] == 1 && !visited[j]) {//如果两点之间有边并且没有访问过 
                printf("%c\t", G -> vexs[j]);
                visited[j] = 1;//访问过置为1 
                enQueue(Q, j);//入队 
            }
        }
    }
}

int main() {
    Graph* G = initGraph(5);//初始化图 
    int* visited = (int*)malloc(sizeof(int) * G -> vexNum);//申请新空间 
    int i;
    for (i = 0; i < G -> vexNum; i++)
        visited[i] = 0;//初始置为0,表明结点没有访问过 
    int arcs[5][5] = {
        0,1,1,1,0,
        1,0,1,1,1,
        1,1,0,0,0,
        1,1,0,0,1,
        0,1,0,1,0
    };
    createGraph(G, "ABCDE", (int*)arcs);//验证创立图(邻接矩阵) 
    DFS(G, visited, 0);//验证深度优先遍历 
    printf("\n");
    for (i = 0; i < G -> vexNum; i++)
        visited[i] = 0;
    BFS(G, visited, 0);
    printf("\n");
    return 0;
}

运行结果:

 

 

深雨燕纷飞
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言实现图的邻接矩阵和BFS DFS
qq_33901297的博客
07-13 1401
我没有写思路，学到这里连着都看不懂的话，还是不要学的好 #include #define MaxVex 100 //最大顶点数 #define INFINITY 65535 //表示∞ #define TRUE 1 #define FALSE 0 typedef char Ve
数据结构：无向图邻接表、邻接矩阵创建及其BFS、DFS遍历(C语言)
weixin_55797565的博客
12-05 4192
实验目的： 1．掌握图的定义和构造方法； 2．掌握图的存储及遍历方法及应用。 实验内容： 编程实现： 1、建立一个以邻接表形式存储的图； 2、建立一个以邻接矩阵形式存储的图； 3、以邻接表形式存储的图的深度优先遍历； 4、以邻接表形式存储的图的广度优先遍历； 5、以邻接矩阵形式存储的图的深度优先遍历； 6、以邻接矩阵形式存储的图的广度优先遍历； 学习邻接表时候画的图，如果没有动态视频教程的话，个人觉得看着代码一层一层画图很容易理解 个人比较懒，下面是代码：（注释应该能看懂吧哈哈哈
C语言(邻接矩阵,邻接表实现dfs,bfs)
m0_45311187的博客
06-08 1593
dfs 1.邻接矩阵 #include<stdio.h> #include<string.h> #define MVNum 10 //最大顶点数 typedef struct{ char vexs[MVNum]; //顶点表 int arcs[MVNum][MVNum]; //邻接矩阵 int vexnum,arcnum; }AMGraph; int visited[MVNum]; void
C语言邻接表、邻接矩阵的BFS/DFS方法实现
weixin_45230280的博客
01-22 689
C语言邻接表、邻接矩阵的BFS/DFS方法实现引入C语言邻接表的BFS/DFS方法实现：邻接矩阵的BFS/DFS实现及结构体的定义： 引入 看了一下，在网上似乎很少有邻接表和邻接矩阵的简单可行的BFS/DFS方法进行实现，于是我就把我的代码贴上来供大家参考好了。 C语言邻接表的BFS/DFS方法实现： #include <stdio.h> #include "stdlib.h" #define VNum 100 int visited[VNum] = {0}; int visited2[VNu
邻接矩阵/图/DFS/BFS
m0_61548909的博客
06-06 2075
目录1.邻接矩阵的表示2.邻接矩阵的存储3.采用邻接矩阵表示法创建无向网 4.基于邻接矩阵的图上各类操作 5.DFS6.BFS7.测试程序（待完成） 权与网连通分量（强连通分量） 无向图 有向图 网（有权图） 3.采用邻接矩阵表示法创建无向网 创建无向图和有向图的区别 优缺点 声明 广度优先搜索需要的队列（图的遍历） 基于邻接矩阵的图上操作 5.DFS 深度优先搜索属于图算法的一种，是一个针对图和树的遍历算法，英文缩写为DFS即Depth First Search。深度优先搜
图——邻接矩阵 DFS、BFS（C语言实现）
半跨考本科生的代码日常
12-02 75
/访问数组(用来确定元素是不是已经被访问)EdgeType Edge[MaxVexNum][MaxVexNum];//用静态数组存放队列元素。#define MaxVexNum 100//顶点数目的最大值。//队头指针和队尾指针。//DFSTraverse(防止非连通图)//BFSTraverse(防止非连通图)//输入边(此处用无向图举例)//打印图的邻接矩阵。
图的遍历-邻接矩阵实现DFS和BFS，c语言实现
Mrs_fanshuishui的博客
08-12 5045
首先是我个渣对两种遍历方法的看法 BFS:寻找最优解,比如最短路径.时间复杂度更低，一圈一圈搜索,深度不大的时候比较适用，但是 DFS:不撞南墙不回头,所以相对于BFS 找到的不一定是最优解,但是其对于空间的消耗较少,因为不需要存储临时节点   对于DFS，其实现方法类似于先序遍历，不断递归的调用DFS函数，依次向下搜寻。   首先是图结构体的实现 struct GNode { ...
C语言 图的邻接矩阵和邻接表存储实现
i13145821的博客
01-25 772
1、理解并掌握图的邻接矩阵存储；2、理解并掌握图的邻接表存储；3、实现两种存储结构。
用邻接矩阵创建无向图，实现DFS+BFS
HXZ_CREATE的博客
06-13 1405
由于图的复杂结构，其物理位置与逻辑位置并不匹配，不能用一维数组来存储图。可考虑用一维数组来存储图的结点信息，二维数组来存储节点间的关系，这种存储方式就叫做邻接矩阵。 图的结点结构定义： typedef struct { char vexs[ MVNum ] ;//存储结点信息 int arcs[ MVNum ][ MVNum ] ; //存储权值 int vexnum , arcnum ;//定义图的节点个数和边的条数 }AMGraph ; 查找结点元素在vexs[]数组中的下标：
图的遍历——DFS, BFS（邻接矩阵，邻接表）——C语言描述
m0_59469991的博客
06-21 760
图的遍历——DFS, BFS（邻接矩阵，邻接表）——C语言描述
C语言：图的DFS和BFS（内附代码和算法思路）.docx
11-01
在本文档中，我们讨论了如何使用C语言实现无向图的深度优先遍历（DFS）和广度优先遍历（BFS）。首先，我们需要理解数据结构中的图，它由顶点（vertices）和边（edges）组成，无向图意味着边没有方向。图的存储通常有...
数据结构图的邻接矩阵和邻接表建立和dfs、bfs算法（C语言）
07-16
程序用交互方式完成图的邻接矩阵和邻接表的构造，并提供了DFS和BFS算法。
03邻接矩阵深度和广度遍历DFS_BFS.c
11-01
03邻接矩阵深度和广度遍历DFS_BFS.c
图的邻接矩阵表示，深度优先遍历，广度优先遍历实现
03-13
C++实现，数据结构，图的邻接矩阵表示，深度优先遍历，广度优先遍历，DFS，BFS，为什么要五十个字才能上传啊
图--邻接矩阵-遍历.pdf
10-01
综上所述，这个文件主要是关于如何用C语言实现基于邻接矩阵的图数据结构，以及相关的辅助数据结构（如队列）和操作，包括图的创建、定位、遍历等。这些基本操作是图算法的基础，对于理解和实现各种图论问题至关重要...
C语言中的回调函数定义以及使用回调函数的例子。
2402_84885073的博客
06-20 425
在C语言中，回调函数（Callback Function）是一种特殊的函数，它作为参数传递给另一个函数（我们称之为主函数或调用者），并在需要的时候由主函数来调用。回调函数允许主函数在适当的时候执行特定的操作，而不需要知道这些操作的具体细节。回调函数的一个常见应用是在事件驱动编程中，当某个特定事件发生时（如用户点击按钮或定时器到期），就会调用回调函数来处理该事件。在这个例子中，我们定义了一个回调函数类型。类型的参数（即回调函数），以及两个。，它们分别实现了加法和乘法操作。的结果，并返回这个结果。
C语言中的可变参数函数（如printf）是如何实现的。
2402_84885073的博客
06-20 250
请注意，这个例子只是为了说明可变参数函数的基本原理，并没有处理所有的边界情况和错误。在实际编写可变参数函数时，你需要更加小心，并确保正确处理所有可能的参数类型和错误情况。函数就是一个典型的可变参数函数，它接受一个格式字符串，后面跟着任意数量的参数，这些参数根据格式字符串中的占位符进行格式化输出。在C语言中，可变参数函数（variadic functions）是一种可以接受不确定数量参数的函数。在函数内部，你可以使用上述宏来遍历参数列表。中定义的宏，用于在函数内部处理可变参数。（在某些系统中可能是。
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5111
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
1719378276792.jpg
最新发布
06-26
1719378276792.jpg
c语言邻接矩阵bfs和dfs
12-08
以下是C语言中邻接矩阵实现的BFS和DFS算法的示例代码： BFS算法： ```c #include #include #define MaxInt 32767 #define MVNum 100 typedef char VerTexType; typedef int ArcType; typedef struct { VerTex...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值