数据结构与算法（五）图c语言实现（带源码）

最新推荐文章于 2023-12-12 14:39:50 发布
最新推荐文章于 2023-12-12 14:39:50 发布
阅读量488 收藏 3
点赞数 1
分类专栏： 数据结构与算法 文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52534495/article/details/113789175
版权

数据结构与算法（五）图

  1. 邻接矩阵存储实现、深度优先及广度优先遍历
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>

#define MAX 100
#define MAXNUM 32767//正无穷

typedef struct
{
	char vexs[MAX];//顶点表 （顶点类型是char）
	int arcs[MAX][MAX];//邻接矩阵  （边的类型是int）
	int vexnum, arcnum;//图当前的点数和边数
}AMGraph;

typedef struct
{
	char data[MAX];
	int front, rear;
}SeQueue;

int* Dvisited;
int* Bvisited;

int LocateVex(AMGraph* pG, char* pV)
{
	int i;
	for (i = 0; i < pG->vexnum; ++i)
	{
		if ( *pV == pG->vexs[i])
			break;
	}
	return i;
}

void initUDN(AMGraph* pG)//初始化无向网
{
	char V1, V2;
	int i,j,w;
	printf("请输入顶点数： ");
	scanf_s("%d",&pG->vexnum);
	printf("请输入边数： ");
	scanf_s("%d",&pG->arcnum);

	for (int k = 0; k < pG->vexnum; ++k)
	{
		printf("请输入第%d个顶点的数据： ",k+1);
		scanf_s(" %c",&pG->vexs[k]);
	}

	for (int k = 0; k < pG->vexnum; ++k)
	{
		for (int m = 0; m < pG->vexnum; ++m)
		{
			pG->arcs[k][m] = MAXNUM;
			if (k == m)
				pG->arcs[k][m] = 0;
		}
	}

	for (int k = 0; k < pG->arcnum; ++k)
	{
		printf("请输入第一个顶点元素： ");
		scanf_s(" %c",&V1);
		printf("请输入第二个顶点元素： ");
		scanf_s(" %c", &V2);
		printf("请输入两个顶点的权值： ");
		scanf_s("%d", &w);

		i = LocateVex(pG,&V1);
		j = LocateVex(pG,&V2);
		pG->arcs[i][j] = w;
		pG->arcs[j][i] = pG->arcs[i][j];
	}

	Dvisited = (int*)malloc(sizeof(int) * (pG->vexnum));
	for (int m = 0; m < pG->vexnum; ++m)
	{
		Dvisited[m] = 0;
	}

	Bvisited = (int*)malloc(sizeof(int) * (pG->vexnum));
	for (int m = 0; m < pG->vexnum; ++m)
	{
		Bvisited[m] = 0;
	}
}

void DFS(AMGraph* pG, char V)
{
	int i,j;
	i = LocateVex(pG,&V);
	Dvisited[i] = 1;
	if(Dvisited[i]=1)
		printf("访问的元素是： %c\n", V);
	for (j = 0; j < pG->vexnum; j++)
	{
		if ((pG->arcs[i][j] == 1) && (Dvisited[j] == 0))
		{
			DFS(pG, pG->vexs[j]);
		}
	}
}

void initQueue(SeQueue* Sq)
{
	Sq->front = -1;
	Sq->rear = Sq->front;
}

bool is_empty(SeQueue* Sq)
{
	if (Sq->rear == Sq->front)
		return true;
	else
		return false;
}

bool is_full(SeQueue* Sq)
{
	if ((Sq->rear + 1) % MAX == Sq->front)
		return true;
	else
		return false;
}

bool InQueue(SeQueue* Sq, char C)
{
	if (is_full(Sq))
		return false;
	else
	{
		Sq->rear = (Sq->rear + 1) % MAX;
		Sq->data[Sq->rear] = C;
		return true;
	}
}

bool OutQueue(SeQueue* Sq, char* pC)
{
	if (is_empty(Sq))
		return false;
	else
	{
		Sq->front = (Sq->front + 1) % MAX;
		*pC = Sq->data[Sq->front];
		Sq->data[Sq->front] = NULL;
		return true;
	}
}

void BFS(AMGraph* pG, char C)
{
	SeQueue Q;
	int i, j,k;
	char w;
	i = LocateVex(pG,&C);
	Bvisited[i]=1;
	InQueue(&Q,C);
	while (!is_empty(&Q))
	{
		OutQueue(&Q,&w);
		k = LocateVex(pG,&w);
		printf("%c\t",w);
		for (j = 0; j < pG->vexnum; ++j)
		{
			if (Bvisited[j] == 0 && pG->arcs[k][j] == 1)
			{
				Bvisited[j] = 1;
				InQueue(&Q,pG->vexs[j]);
			}
		}
	}
}

int main()
{
	int Dflag = 1;
	int Bflag = 1;
	int n;
	AMGraph G;
	initUDN(&G);
	printf("请输入这个图含有的子图个数：");
	scanf_s("%d",&n);
	for (int i = 0; i < G.vexnum; ++i)
	{
		for (int j = 0; j < G.vexnum; ++j)
		{
			printf("%d\t",G.arcs[i][j]);
			if (j == (G.vexnum - 1))
				printf("\n");
		}
	}
	printf("============深度优先遍历==============");
	DFS(&G,'A');
	while (Dflag <= n) //这样可以适应非连通图
	{
		for (int i = 0; i < G.vexnum; ++i)
		{
			if (Dvisited[i] == 0)
			{
				DFS(&G, G.vexs[i]);
			}
		}
		Dflag++;
	}
	printf("======================================");

	printf("============广度优先遍历==============");
	BFS(&G,'A');
	while (Bflag <= n)
	{
		for (int i = 0; i < G.vexnum; ++i)
		{
			if (Bvisited[i] == 0)
			{
				BFS(&G, G.vexs[i]);
			}
		}
		Bflag++;
	}
	printf("======================================");
}

也适合非连通图

  1. 邻接表存储实现、深度优先及广度优先遍历
#include  <stdio.h>
#include <stdlib.h>
#include <malloc.h>

#define MAX 100

typedef struct arc
{
	int adjvex;
	int weight;
	struct arc* next;
}ArcNode;//边表节点

typedef struct
{
	char data;
	ArcNode* firstarc;
}VertexNode;

typedef struct
{
	VertexNode vertex[MAX];
	int vernum, arcnum;
}ALGraph;

typedef struct node
{
	char data[MAX];
	int front, rear;
}SeQueue;

int* Dvisited;
int* Bvisited;

int LocateVex(ALGraph* pG, char* pV)
{
	int i;
	for (i = 0; i < pG->vernum; ++i)
	{
		if (*pV == pG->vertex[i].data)
			break;
	}
	return i;
}

void initGraph(ALGraph* pG)
{
	int i, j, w;
	printf("请你输入顶点数： ");
	scanf_s("%d",&(pG->vernum));
	printf("请输入你的边数： ");
	scanf_s("%d",&(pG->arcnum));

	for (int k = 0; k < pG->vernum; ++k)
	{
		printf("请输入第%d个节点的元素： ",k+1);
		scanf_s(" %c",&(pG->vertex[k].data));
		pG->vertex[k].firstarc = NULL;
	}
	for (int k = 0; k < pG->arcnum; ++k)
	{
		char V1, V2;
		printf("请输入两个互相连接的元素：");
		printf("第一个元素是： ");
		scanf_s(" %c",&V1);
		printf("第二个元素是： ");
		scanf_s(" %c", &V2);
		i = LocateVex(pG,&V1);
		j = LocateVex(pG,&V2);

		ArcNode* pNew1 = (ArcNode*)malloc(sizeof(ArcNode));
		if (pNew1 == NULL)
		{
			exit(-1);
			return;
		}
		pNew1->adjvex = j;
		pNew1->next = pG->vertex[i].firstarc;
		pG->vertex[i].firstarc = pNew1;

		ArcNode* pNew2 = (ArcNode*)malloc(sizeof(ArcNode));
		if (pNew2 == NULL)
		{
			exit(-1);
			return;
		}
		pNew2->adjvex = i;
		pNew2->next = pG->vertex[j].firstarc;
		pG->vertex[j].firstarc = pNew2;
	}

	Dvisited = (int*)malloc(sizeof(int)*pG->vernum);
	for (int i = 0; i < pG->vernum; ++i)
		Dvisited[i] = 0;

	Bvisited = (int*)malloc(sizeof(int) * pG->vernum);
	for (int i = 0; i < pG->vernum; ++i)
		Bvisited[i] = 0;
}

void DFS(ALGraph* pG, char V)
{
	int i;
	ArcNode* p;
	i = LocateVex(pG,&V);
	Dvisited[i] = 1;
	if (Dvisited[i] == 1)
		printf("访问的元素是:%c\n",pG->vertex[i].data);
	p = pG->vertex[i].firstarc;
	while (p != NULL)
	{
		if (Dvisited[p->adjvex] == 0)
		{
			DFS(pG,pG->vertex[p->adjvex].data);
		}
		p = p->next;
	}
}

void initQueue(SeQueue* Sq)
{
	Sq->front = -1;
	Sq->rear = Sq->front;
}

bool is_empty(SeQueue* Sq)
{
	if (Sq->front == Sq->rear)
		return true;
	else
		return false;
}

bool is_full(SeQueue* Sq)
{
	if ((Sq->rear + 1) % MAX == Sq->front)
		return true;
	else
		return false;
}

bool InQueue(SeQueue* Sq,char c)
{
	if (is_full(Sq))
		return false;
	else
	{
		Sq->rear = (Sq->rear + 1) % MAX;
		Sq->data[Sq->rear] = c;
	}
	return true;
}

bool OutQueue(SeQueue* Sq, char* pC)
{
	if (is_empty(Sq))
		return false;
	else
	{
		Sq->front = (Sq->front + 1) % MAX;
		*pC = Sq->data[Sq->front];
		Sq->data[Sq->front] = NULL;
		return true;
	}
}

void BFS(ALGraph* pG, char C)
{
	int i,j,w;
	char V;
	ArcNode* p;
	SeQueue Q;
	//printf("%c\t",C);
	i = LocateVex(pG,&C);
	Bvisited[i] = 1;
	initQueue(&Q);
	InQueue(&Q,C);
	while (!is_empty(&Q))
	{
		OutQueue(&Q,&V);
		j=LocateVex(pG,&V);
		p = pG->vertex[j].firstarc;
		printf("访问的元素是：%c\n",V);
		while (p != NULL)
		{
			w = p->adjvex;
			if (Bvisited[w] == 0)
			{
				//printf("%c\t",pG->vertex[w].data);
				Bvisited[w]=1;
				InQueue(&Q,pG->vertex[w].data);
			}
			p = p->next;
		}
	}
}

int main()
{
	int Dflag = 1;
	int Bflag = 1;
	int n;
	ALGraph G;
	initGraph(&G);
	printf("请您输入这个图有几个子图：");
	scanf_s("%d", &n);
	for (int i = 0; i < G.vernum; ++i)
	{
		ArcNode* p = G.vertex[i].firstarc;
		printf("%c: ",G.vertex[i]);
		while (p != NULL)
		{
			printf("%c", G.vertex[p->adjvex].data);
			p = p->next;
		}
		printf("\n");
	}
	printf("============深度优先遍历==============\n");
	DFS(&G,'A');
	while (Dflag <= n)
	{
		for (int i = 0; i < G.vernum; ++i)
		{
			if (Dvisited[i] == 0)
				DFS(&G, G.vertex[i].data);
		}
		Dflag++;
	}
	printf("======================================\n");

	printf("============广度优先遍历==============\n");
	BFS(&G,'A');
	while(Bflag<=n)
	{
		for (int i = 0; i < G.vernum; ++i)
		{
			if (Bvisited[i] == 0)
				BFS(&G, G.vertex[i].data);
		}
		Bflag++;
	}
	printf("======================================\n");
	return 0;
}

这里是头插导致和临界矩阵输出有些不一样如有问题请多指教

一个董憨憨
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构关于图的算法C语言实现
12-10
关于图的各种算法，C语言实现。 class Graph { public: int numVertex; //图的顶点的个数 int numEdge; //图的边的数目 int *Mark; /*Mark指针指向保存有图的顶点的标志位的数组,标志位用来标记某顶点是否被访问过*/ int *Indegree; //Indegree指针指向保存有图的顶点的入度的数组 Graph(int numVert) { //构造函数 numVertex = numVert; //确定图的顶点的个数 numEdge = 0; //确定图的边的数目 Indegree = new int[numVertex]; /*为保存图的顶点的入度申请数组,Indegree为数组指针*/ Mark = new int[numVertex]; /*为图的顶点的标志位申请数组,Mark为数组指针*/ for (int i = 0; i < numVertex; i ++) { /*确定图的顶点的标志位和入度,即所有顶点的标志位初始化为未被访问过,入度初始化为0*/ Mark[i] = UNVISITED; Indegree[i] = 0; } }
数据结构(C语言版)树和图的完整源代码
06-18
数据结构(C语言版)树和图的完整源代码，建议运行环境Visual Stadio 2005或更高版本
C语言数据结构 图 基本操作的实现
最新发布
2301_77527830的博客
12-12 443
【代码】C语言数据结构 图 基本操作的实现。
数据结构无向图的操作（C语言）
多低调的博客
12-02 4201
目录 //1、含邻接矩阵的图结构 //2、创建邻接矩阵 //3、打印邻接矩阵 //4、邻接表的图结构 //5、创建邻接表 //6、打印邻接表 //7、深度优先搜索 //8、广度优先搜索 //9、带主函数完整测试源码 //1、含邻接矩阵的图结构 用邻接矩阵来表示图： //定义邻接矩阵的图结构 typedef struct graph { elemtype data[N + 1];//存放顶点，不使用data[0]存放 int side[N + 1][N + 1];//邻接矩阵，同
C语言数据结构：图！
qq_42319810的博客
07-10 1516
目录一、图的基本概念 1、基本概念 2、无向图、有向图 3、简单图、多重图 4、顶点的度、入度、出度 5、顶点-顶点的关系描述 6、连通图、强连通图 7、研究图的局部--子图 8、连通分量 9、生成树 10、生成森林 11、边的权、带权图/网 12、几种形态特殊的图 13、小结二、图的存储1、邻接矩阵（空间复杂度 = O（n*n））2、邻接表3、十字矩阵 和 邻接多重表 1、十字链表法​编辑 2、十字链表法性能分析 3、邻接多重表法 4、小结三、图的基本操作 1、Adjacent(G,x,y)：判断图G是
基于C语言（数据结构）的学生奖金管理系统课程设计和文件的操作（附源码）
秋日物语的博客
10-19 2484
该系统可以作为学生管理系统，也可以最为奖学金评定系统
C语言版数据结构- C语言实现串，含详细的源代码
weixin_45509705的博客
10-01 1258
HString.h 头文件 #include <stdio.h> #include <stdlib.h> //定义函数返回的类型 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 //定义数据元素的类型为字符型 typedef int Status; typedef char ElemType; //定义单链表的存储结构 ty.
C语言数据结构：顺序表（附源码）
no_pain_no_gain_的博客
03-28 1550
1.运行界面 2.编程过程过程中的思考 1.不按课本中的思想（从表头开始插入），而是从表中或表尾开始插入数据元素，结果如何，运行如下： 请输入您想进行的操作序号： 1.新建一个空表 2.在指定位置插入一个数据元素 3.删除指定位置的数据元素 4.修改指定位置元素 5.输出表内全部元素 6.查询某位置的数据 7.查询某数据的位置 8.退出 ...
C语言数据结构-多功能图书管理系统课程设计（文末附源码）
秋日物语的博客
03-19 8454
一个用C语言数据结构写的多功能图书管理系统课设，包含用户和管理员，功能多
『初阶数据结构 • C语言』⑩ - 队列的概念与实现（附完整源码）
花想云的博客
01-18 1625
队列对于临时数据的处理也十分有趣，它跟栈一样都是有约束条件的数组（或者链表）。区别在于我们想要按什么顺序去处理数据，而这个顺序当然是要取决于具体的应用场景。你可以将队列想象成是电影院排队。排在最前面的人会最先离队进入影院。套用到队列上，就是首先加入队列的，将会首先从队列移出。因此计算机科学家都用缩写“FIFO”（first in, first out）先进先出，来形容它。
数据结构之图（C语言）
sskdspdl的博客
10-22 2006
用C语言实现图的创建与遍历
C语言 输入无向图连通图的顶点数、顶点信息、边数、顶点对序列及遍历的起始点序号，输出深度优先遍历序列
05-26
①无向图的非递归深度优先搜索需借用一个堆栈保存被访问过的顶点，以便回溯查找已被访问结点的被访问过的邻接点。 ②访问起始顶点v0,visited[v0]标记1,v0入栈，指针p指向v0对应的边表首结点； ③从左到右扫描p所指的边表（邻接表），查找边表中对应顶点的visited[v]标志为0的结点； ④若找到所求结点，则对应的顶点记为v。然后访问v,visited[v]标记1,v入栈,p指向v对应的边表首结点。否则，从栈中出栈一个顶点作为v（即回溯）p指向v对应的边表首结点； ⑤重复②、③直至所有的顶点都被访问一次。
数据结构实验五（二叉树的建立及遍历）题目和源程序
04-02
实验内容 1．编写程序任意输入二叉树的结点个数和结点值，构造一棵二叉树，采用三种递归遍历算法(前序、中序、后序)对这棵二叉树进行遍历并计算出二叉树的高度。 2 .编写程序生成下面所示的二叉树，并采用中序遍历的非递归算法对此二叉树进行遍历。
数据结构c语言版源代码,数据结构C语言版线性表源代码.doc
weixin_35733852的博客
05-19 259
#include #include #include #include #define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define OK 1#define ERROR -1#define OVERFLOW -1#define ENDFLAG 0typedef int Status;typedef int ElemType;...
算法:c语言实现(第5部分)图算法 源代码,(赠品)算法：C语言实现（第5部分）：图算法（英文影印版·第3版）...
weixin_29883867的博客
05-24 209
前言GRAPHS AND GRAPH algorithms are pervasive in modern computing applications. This book describes the most important known methods for solving the graph-processing problems that arise in practice. Its...
python算法很难吗_Python算法很难吗？编程届神书《算法图解》PDF电子版分享给你...
weixin_39882317的博客
12-08 222
原标题：Python算法很难吗？编程届神书《算法图解》PDF电子版分享给你Python算法很难吗？IT届神书《算法图解》PDF电子版分享给你许多小伙伴后台私信柠檬说，python算法让自己很头疼，有没有可以让算法像小说一样有趣的书籍资料呢？看这里吧！柠檬为大家找到了这本《算法图解》的PDF电子版！让你在学习python的路上变得轻松有趣！ 内 容 提 要本书示例丰富，图文并茂，以简明易懂的方式阐释...
图的常用算法c语言,C语言实现图的搜索算法示例
weixin_36104484的博客
05-18 377
本文实例讲述了C语言实现图的搜索算法。分享给大家供大家参考，具体如下：在游戏中，常常遇到路径规划问题，用到图的相关算法，我们以简单图来学习。图通常有两种表示方式，矩阵和邻接表。矩阵表示简单，运算快，但当矩阵是稀疏矩阵的时候就存在空间浪费的问题，并且效率也会下降，而邻接表节约空间，并且由于边是连续访问，时间效率也比较高。在本文中，我们将以邻接表来表示图。#include#includeusing n...
数据结构算法之 C 语言实现
月小水长
05-04 3490
单链表算法大全（包含所有常见操作）：单链表算法链接 二叉树算法大全（包含所有常见操作）：二叉树算法链接 迪杰斯特拉算法：迪杰斯特拉算法链接 矩阵无向图算法（生成、BFS、DFS）：矩阵无向图算法链接 邻接表无向图算法（生成、BFS、DFS）：邻接表无向图算法链接 快速排序算法：快速排序算法链接 欢迎各位赏star ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值