数据结构12.1-邻接表

最新推荐文章于 2023-07-24 07:00:00 发布
最新推荐文章于 2023-07-24 07:00:00 发布
阅读量431 收藏
点赞数
文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62035627/article/details/125073041
版权

目录

一、定义

二、初始化

三、打印邻接表

四、广度优先遍历

五、测试函数

六、完整代码

七、运行结果

一、定义

邻接表是图的一种链式存储结构。使用邻接表的目的是为了避免当边数目相对于顶点数目很小的时候，对存储空间造成了浪费.。

其中使用队列与图相关操作与图的遍历一样，这里就不过多赘述

typedef struct AdjacencyNode {
	int column;                     
	AdjacencyNode* next;
}AdjacencyNode, *AdjacentNodePtr;
// 邻接表
typedef struct AdjacencyList {
	int numNodes;
	AdjacencyNode* headers;
}AdjacencyList, *AdjacencyListPtr;

二、初始化

AdjacencyListPtr graphToAdjacentList(GraphPtr paraPtr) {
	// 分配空间
	int i, j, tempNum;
	AdjacentNodePtr p, q;
	tempNum = paraPtr->numNodes;
	AdjacencyListPtr resultPtr = (AdjacencyListPtr)malloc(sizeof(struct AdjacencyList));
	resultPtr->numNodes = tempNum;
	resultPtr->headers = (AdjacencyNode*)malloc(tempNum * sizeof(struct AdjacencyNode));
	
	// 填充数据
	for (i = 0; i < tempNum; i ++) {
		//Initialize headers.
		p = &(resultPtr->headers[i]);
		p->column = -1;
		p->next = NULL;

		for (j = 0; j < tempNum; j ++) {
			if (paraPtr->connections[i][j] > 0) {
				//Create a new node.
				q = (AdjacentNodePtr)malloc(sizeof(struct AdjacencyNode));
				q->column = j;
				q->next = NULL;

				// 连接
				p->next = q;
				p = q;
			}
		}
	}

	return resultPtr;
}

三、打印邻接表

void printAdjacentList(AdjacencyListPtr paraPtr) {
	int i;
	AdjacentNodePtr p;
	int tempNum = paraPtr->numNodes;

	printf("This is the graph:\r\n");
	for (i = 0; i < tempNum; i ++) {
		p = paraPtr->headers[i].next;
		while (p != NULL) {
			printf("%d, ", p->column);
			p = p->next;
	 }
		printf("\r\n");
	}
}

四、广度优先遍历

void widthFirstTranverse(AdjacencyListPtr paraListPtr, int paraStart){
	printf("width first \r\n");
	// 用队列去管理指针
	int i, j, tempNode;
	AdjacentNodePtr p;
	i = 0;

	// 初始化数据
	visitedPtr = (int*) malloc(paraListPtr->numNodes * sizeof(int));
	
	for (i = 0; i < paraListPtr->numNodes; i ++) {
		visitedPtr[i] = 0;
	}

	QueuePtr tempQueuePtr = initQueue();
	printf("%d\t", paraStart);
	visitedPtr[paraStart] = 1;
	enqueue(tempQueuePtr, paraStart);
	// printf("After enqueue\r\n");
	while (!isQueueEmpty(tempQueuePtr)) {
		// printf("First while\r\n");
		tempNode = dequeue(tempQueuePtr);

		for (p = &(paraListPtr->headers[tempNode]); p != NULL; p = p->next) {
			j = p->column;
			// printf("j = %d \r\n", j);
			if (visitedPtr[j]) 
				continue;

			printf("%d\t", j);
			visitedPtr[j] = 1;
			enqueue(tempQueuePtr, j);
		}
	}
	printf("\r\n");
}

五、测试函数

void testGraphTranverse() {
	int i, j;
	int myGraph[5][5] = { 
		{0, 1, 0, 1, 0},
		{1, 0, 1, 0, 1}, 
		{0, 1, 0, 1, 1}, 
		{1, 0, 1, 0, 0}, 
		{0, 1, 1, 0, 0}};
	int** tempPtr;
	printf("Preparing data\r\n");
		
	tempPtr = (int**)malloc(5 * sizeof(int*));
	for (i = 0; i < 5; i ++) {
		tempPtr[i] = (int*)malloc(5 * sizeof(int));
	}
	 
	for (i = 0; i < 5; i ++) {
		for (j = 0; j < 5; j ++) {
			//printf("i = %d, j = %d, ", i, j);
			//printf("%d\r\n", tempPtr[i][j]);
			tempPtr[i][j] = myGraph[i][j];
			//printf("i = %d, j = %d, %d\r\n", i, j, tempPtr[i][j]);
		}
	}
 
	printf("Data ready\r\n");
	
	GraphPtr tempGraphPtr = initGraph(5, tempPtr);
	AdjacencyListPtr tempListPtr = graphToAdjacentList(tempGraphPtr);

	printAdjacentList(tempListPtr);

	widthFirstTranverse(tempListPtr, 4);
}

六、完整代码

#include <stdio.h>
#include <malloc.h>
#include <stdbool.h> 
#define QUEUE_SIZE 10

int* visitedPtr;  // 标志指针


typedef struct Graph{
	int** connections;  // 结点
	int numNodes;       // 数据
} *GraphPtr;


GraphPtr initGraph(int paraSize, int** paraData) {
	int i, j;
	GraphPtr resultPtr = (GraphPtr)malloc(sizeof(struct Graph));
	resultPtr -> numNodes = paraSize;
	//resultPtr -> connections = (int**)malloc(paraSize * paraSize * sizeof(int));
	resultPtr -> connections = (int**)malloc(paraSize * sizeof(int*));
	for (i = 0; i < paraSize; i ++) {
		resultPtr -> connections[i] = (int*)malloc(paraSize * sizeof(int));
		for (j = 0; j < paraSize; j ++) {
			resultPtr -> connections[i][j] = paraData[i][j];
		}
	}
	
	return resultPtr;
}

typedef struct GraphNodeQueue{
	int* nodes;
	int front;
	int rear;
}GraphNodeQueue, *QueuePtr;

// 初始化
QueuePtr initQueue(){
	QueuePtr resultQueuePtr = (QueuePtr)malloc(sizeof(struct GraphNodeQueue));
	resultQueuePtr->nodes = (int*)malloc(QUEUE_SIZE * sizeof(int));
	resultQueuePtr->front = 0;
	resultQueuePtr->rear = 1;
	return resultQueuePtr;
}

// 判断队列是否为空
bool isQueueEmpty(QueuePtr paraQueuePtr){
	if ((paraQueuePtr->front + 1) % QUEUE_SIZE == paraQueuePtr->rear) {
		return 1;
	}

	return 0;
}

void enqueue(QueuePtr paraQueuePtr, int paraNode){
	if ((paraQueuePtr->rear + 1) % QUEUE_SIZE == paraQueuePtr->front % QUEUE_SIZE) {
		printf("Error, trying to enqueue %d. queue full.\r\n", paraNode);
		return;
	}
	paraQueuePtr->nodes[paraQueuePtr->rear] = paraNode;
	paraQueuePtr->rear = (paraQueuePtr->rear + 1) % QUEUE_SIZE;
}


int dequeue(QueuePtr paraQueuePtr){
	if (isQueueEmpty(paraQueuePtr)) {
		printf("Error, empty queue\r\n");
		return NULL;
	}

	paraQueuePtr->front = (paraQueuePtr->front + 1) % QUEUE_SIZE;

	//printf("dequeue %d ends.\r\n", paraQueuePtr->nodes[paraQueuePtr->front]);
	return paraQueuePtr->nodes[paraQueuePtr->front];
}


typedef struct AdjacencyNode {
	int column;
	AdjacencyNode* next;
}AdjacencyNode, *AdjacentNodePtr;

typedef struct AdjacencyList {
	int numNodes;
	AdjacencyNode* headers;
}AdjacencyList, *AdjacencyListPtr;

AdjacencyListPtr graphToAdjacentList(GraphPtr paraPtr) {
	// 分配空间
	int i, j, tempNum;
	AdjacentNodePtr p, q;
	tempNum = paraPtr->numNodes;
	AdjacencyListPtr resultPtr = (AdjacencyListPtr)malloc(sizeof(struct AdjacencyList));
	resultPtr->numNodes = tempNum;
	resultPtr->headers = (AdjacencyNode*)malloc(tempNum * sizeof(struct AdjacencyNode));
	
	// 填充数据
	for (i = 0; i < tempNum; i ++) {
		//Initialize headers.
		p = &(resultPtr->headers[i]);
		p->column = -1;
		p->next = NULL;

		for (j = 0; j < tempNum; j ++) {
			if (paraPtr->connections[i][j] > 0) {
				//Create a new node.
				q = (AdjacentNodePtr)malloc(sizeof(struct AdjacencyNode));
				q->column = j;
				q->next = NULL;

				// 连接
				p->next = q;
				p = q;
			}
		}
	}

	return resultPtr;
}

void printAdjacentList(AdjacencyListPtr paraPtr) {
	int i;
	AdjacentNodePtr p;
	int tempNum = paraPtr->numNodes;

	printf("This is the graph:\r\n");
	for (i = 0; i < tempNum; i ++) {
		p = paraPtr->headers[i].next;
		while (p != NULL) {
			printf("%d, ", p->column);
			p = p->next;
	 }
		printf("\r\n");
	}
}


void widthFirstTranverse(AdjacencyListPtr paraListPtr, int paraStart){
	printf("width first \r\n");
	// 用队列去管理指针
	int i, j, tempNode;
	AdjacentNodePtr p;
	i = 0;

	// 初始化数据
	visitedPtr = (int*) malloc(paraListPtr->numNodes * sizeof(int));
	
	for (i = 0; i < paraListPtr->numNodes; i ++) {
		visitedPtr[i] = 0;
	}

	QueuePtr tempQueuePtr = initQueue();
	printf("%d\t", paraStart);
	visitedPtr[paraStart] = 1;
	enqueue(tempQueuePtr, paraStart);
	// printf("After enqueue\r\n");
	while (!isQueueEmpty(tempQueuePtr)) {
		// printf("First while\r\n");
		tempNode = dequeue(tempQueuePtr);

		for (p = &(paraListPtr->headers[tempNode]); p != NULL; p = p->next) {
			j = p->column;
			// printf("j = %d \r\n", j);
			if (visitedPtr[j]) 
				continue;

			printf("%d\t", j);
			visitedPtr[j] = 1;
			enqueue(tempQueuePtr, j);
		}
	}
	printf("\r\n");
}

void testGraphTranverse() {
	int i, j;
	int myGraph[5][5] = { 
		{0, 1, 0, 1, 0},
		{1, 0, 1, 0, 1}, 
		{0, 1, 0, 1, 1}, 
		{1, 0, 1, 0, 0}, 
		{0, 1, 1, 0, 0}};
	int** tempPtr;
	printf("Preparing data\r\n");
		
	tempPtr = (int**)malloc(5 * sizeof(int*));
	for (i = 0; i < 5; i ++) {
		tempPtr[i] = (int*)malloc(5 * sizeof(int));
	}
	 
	for (i = 0; i < 5; i ++) {
		for (j = 0; j < 5; j ++) {
			//printf("i = %d, j = %d, ", i, j);
			//printf("%d\r\n", tempPtr[i][j]);
			tempPtr[i][j] = myGraph[i][j];
			//printf("i = %d, j = %d, %d\r\n", i, j, tempPtr[i][j]);
		}
	}
 
	printf("Data ready\r\n");
	
	GraphPtr tempGraphPtr = initGraph(5, tempPtr);
	AdjacencyListPtr tempListPtr = graphToAdjacentList(tempGraphPtr);

	printAdjacentList(tempListPtr);

	widthFirstTranverse(tempListPtr, 4);
}


int main(){
	testGraphTranverse();
	return 1;
}

七、运行结果

Preparing data
Data ready
This is the graph:
1, 3,
0, 2, 4,
1, 3, 4,
0, 2,
1, 2,
width first
4       1       2       0       3

南湾河
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
四：图-邻接表的初始化操作及应用
@76135327的博客
11-20 656
内容表结点的形式顶点的存储形式图的结构:两部分找到顶点的下标位置创建图创建网搜索算法：深度创建无向图深度优先遍历广度优先遍历 表结点的形式 typedef struct ArcNode{ int adjvex; //邻接点的下标 struct ArcNode *nextarc; // InfoType *info; }ArcNode; 顶点的存储形式 typedef struct VNode{ char data; ArcNode
图的邻接表存储及图初始化
qq_62185081的博客
12-06 2239
图的邻接表分两部分： 1.顶点表，是一个顺序表，用于存储顶点的值，及与该顶点相邻的第一个顶点指针； 2.边表：是一个链表，每个结点存储与相应顶点有边的另一个顶点编号及下一个顶点指针。 举例，如下所示的图： 其邻接表：测试输入: 0 4 5 0123 0 1 0 2 0 3 1 2 1 3 预期输出： 0->3->2->1 1->3->2->0 2->1->0 3->1->0
6.4.2 邻接表
tang7mj的博客
04-05 2638
邻接表由两个部分组成：顶点数组和邻接表链表。顶点数组中每个元素对应一个顶点，在该元素中存储该顶点以及与之相邻接的所有顶点的信息。邻接表链表存储了从该顶点出发可以到达的所有其他顶点。链表中的每个节点包含两部分：一个指向相邻的顶点的指针和一个指向下一个邻接节点的指针。邻接表的特点：对于无向图或有向图，在添加边时需要在两个顶点之间都加上边。因为邻接表表示的是一个节点所能到达的其他节点，而不是边。
图之邻接表详解（C语言版）
qq_44075108的博客
04-25 9493
图之邻接表详解（C语言版）
【结构与算法】—— 数据结构代码总结 | 数据结构代码大全
热门推荐
看世界，也找自己
10-17 1万+
数据结构是计算机科学与技术专业、计算机信息管理与应用专业，电子商务等专业的基础课，是十分重要的核心课程。所有的计算机系统软件和应用软件都要用到各种类型的数据结构。
数据结构实验报告12.1.rar
12-06
在这个实验报告12.1中，我们很可能会涉及一系列关键的数据结构概念和算法，这些是理解计算机系统运作的基础。 实验报告通常包括以下几个部分：实验目的、预备知识、实验内容、实验步骤、实验结果分析以及实验总结。...
数据结构算法与应用-C++语言描述
10-20
讲述了c++的各种使用的数据结构和算法，对于初学者和已经入门的都很有帮助，里面的内容有 目 录 译者序 前言 第一部分 预备知识 第1章 C++程序设计 1 1.1 引言 1 1.2 函数与参数 2 1.2.1 传值参数 2 1.2.2 模板函数 ...
数据结构(C语言版)[严蔚敏]
04-27
7.2.2 邻接表 7.2.3 十字链表 7.2.4 邻接多重表 7.3 图的遍历 7.3.1 深度优先搜索 7.3.2 广度优先搜索 7.4 图的连通性问题 7.4.1 无向图的连通分量和生成树 7.4.2 有向图的强连通分量 7.4.3 最小生成树 7.4.4 关节点...
【C语言】图的邻接表——超详细解析
Jaye513的博客
12-09 4556
快看这篇，学不会你来打我（bushi）
图：邻接表法创建图
qq_46785243的博客
11-01 2959
邻接表法创建图
数据结构实验3.3：邻接表的初始化、撤销、边的搜索、插入、删除等操作.doc
10-29
数据结构实验报告
图的创建之邻接表法（C语言描述）
YGQ_qq_1435471912
07-17 2757
邻接表，G【N】为指针数组，每个指针对应矩阵每行一个链表，只存非零元素。如下图，第一行就表示的是从0-1，从0-3，如果我们说的是无向图的话，那么一条边会被存储两次 ...
南邮数据结构实验3.3：邻接表的初始化、撤销、边的搜索、插入、删除等操作
Wonz
06-30 9313
题目：参照程序9.6~程序9.10，编写程序，完成邻接表的初始化、撤销、边的搜索、插入、删除等操作。 部分代码： 邻接表的结构体定义： //邻接表的结构体定义 typedef struct ENode{ int adjVex; //任意顶点u相邻的顶点 ElemType w; //边的权值 struct ENode *...
图的邻接表存储法：高效节省空间的图表示方法
最新发布
m0_68805093的博客
07-24 1654
在图论中，图是一种常见的数据结构，用于表示各种实际问题中的关系。图的存储方法有多种，其中邻接表存储法是一种常用且高效的表示方法。本文将详细介绍图的邻接表存储法及其实现原理，同时分析其优缺点，并提供实际应用示例，以帮助读者深入了解和应用这一图表示方法。// 定义图的边结构// 与边相连的当前此顶点的索引Edge* next;// 指向下一个邻接边的指针} Edge;// 定义图的顶点结构// 顶点数据// 指向第一个邻接边的指针} Vertex;// 定义图的邻接表结构。
数据结构-邻接表
qq_40369277的博客
07-01 889
求最短路径时使用邻接矩阵，当边数M远小于点数N的平方时，我们称为稀疏图，M相对较大的图称为稠密图。稀疏图会造成内存空间的浪费（使用了N*N矩阵存储），而算法复杂度也与矩阵大小的平方成正比关系，这时使用邻接表可以降低时间复杂度。有向图邻接表的实现...
图的邻接表创建输出
keepmovingha的专栏
12-03 1万+
邻接表是数组与链表相结合的存储方式，即由顶点表和边表构成。顶点表：图中的顶点用一个一维数组存储（也可以用单链表存储），对于顶点数组还需存储指向第一个邻接点的指针，一遍查找顶点的边的信息。边表：即每个顶点的v的所有邻接点构成一个线性表，用单链表存储。 顶点表的结点由data和和fristedge两个域表示，data是数据域，存储顶点信息，fristedge是指针域，指向边表的第一个顶点，即顶点的第
数据结构实验3--图以邻接表为存储结构的初始化，遍历，迪杰斯特拉算法求最短路径（实验内容3~4~5）
VAEaaaa的博客
04-28 525
运行结果： 源文件： #include "邻接表宽度优先遍历的queue.h" //邻接表的初始化 Status Init(LGraph* lg, int nSize) { int i; lg->numofDot = nSize; lg->numofEdge = 0; lg->a = (ENode**)malloc(nSize * sizeof(ENode*)); if (!lg->a) { return ERROR; } else { for (i =
图的邻接表存储结构
qq_55109560的博客
05-12 1551
实验的问题和要求： 建立图的邻接表存储结构，并将邻接表输出，对其进行深度优先遍历和广度优先遍历。 源程序及注释 #include<iostream> usingnamespacestd; #defineERROR0 #defineOK1 typedefintStatus; #defineTRUE1 #define FALSE 0 //图的邻接表存储表示 #defineMVNum 100 //最大定点数 #defineVertexTypec...
图——课上课后练
Junds0的博客
05-14 2136
第1关：图的邻接矩阵存储及图初始化 本关任务：根据下面的描述和要求，完成图的邻接矩阵数据结构定义，及图初始化函数。 #include <stdio.h> #include <stdlib.h> #define N 6 #define MAX 999 //邻接矩阵数据结构 typedef struct{ int vcount;//顶点数 int type ;//0 无向图，1 有向图 char vexs[N] ; // 顶点信息 int arc

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值