图 邻接矩阵 邻接表

最新推荐文章于 2023-07-15 21:03:33 发布
最新推荐文章于 2023-07-15 21:03:33 发布
阅读量1.3k 收藏 7
点赞数 3
分类专栏： 算法与数据结构 文章标签： 图 邻接矩阵 邻接表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/niuyisheng/article/details/9345097
版权

1.图常用的两种存储结构：邻接矩阵和邻接表。

2. 邻接矩阵结构和操作定义

SeqQueue.h

//功能：邻接矩阵图的广度遍历用到的队列结构体
#define QUEUE_MAXSIZE 256
typedef struct{
	int Data[QUEUE_MAXSIZE];	//QUEUE_MAXSIZE在GraphTest.cpp文件中定义
	int head;
	int tail;
}SeqQueue;

//队列相关操作
void QueueInit(SeqQueue *Q){
	Q->head=Q->tail = 0;
}
//因为判断空函数不设计改变队列Q，所以参数不是指针变量
int QueueIsEmpty(SeqQueue *Q){
	return (Q->head == Q->tail);
}

int QueueIsFull(SeqQueue *Q){
	return ((Q->tail + 1) %QUEUE_MAXSIZE == Q->head);
}

int QueueIn(SeqQueue *Q, int ch){
	if(QueueIsFull(Q)){
		printf("队列已满，无法再插入！！");
		return 0;
	}
	Q->Data[Q->tail] = ch;
	Q->tail = (Q->tail + 1)%QUEUE_MAXSIZE;
	return 1;
}

int QueueOut(SeqQueue *Q, int *ch){
	if(QueueIsEmpty(Q)){
		printf("队列已空！！");
		return 0;
	}
	*ch = Q->Data[Q->head];
	Q->head = (Q->head + 1)%QUEUE_MAXSIZE;
	return 1;
}


AdjMatrixGraph.h

#include"SeqQueue.h"
#define VERTEX_MAX 26					//图的最大顶点数，26个字母
#define MAXVALUE 32767					//表示两点间不构成边
//Prim算法用到
#define USED 0			//已使用，加入U集合
#define NOADJ -1		//非邻接点

//功能：邻接矩阵结构体
typedef struct{
	char Vertex[VERTEX_MAX];			//保存顶点信息
	int Endges[VERTEX_MAX][VERTEX_MAX];	        //保存边的权
	int isTrav[VERTEX_MAX];				//顶点遍历标识
	int VertexNum;					//顶点总数
	int EndgeNum;					//边总数
	int GraphType;					//图的类型
}MatrixGraph;

/*--------------------------函数原型声明 start----------------------*/
void CreateMatrixGraph(MatrixGraph *G);			//功能：创建邻接矩阵图
void OutMatrix(MatrixGraph *G);				//功能：输出邻接矩阵图
void BFSTraverse(MatrixGraph *G);			//功能：广度优先遍历主函数
void BFSM(MatrixGraph *G, int k);			//功能：广度优先遍历具体实现
void DFSTraverse(MatrixGraph *G);			//功能：深度优先遍历主函数
void DFSM(MatrixGraph *G, int k);			//功能：深度优先遍历具体实现
void Prim(MatrixGraph G);				//功能：Prim最小生成树算法具体实现
void Dijkstra(MatrixGraph G);				//功能：Dijkstra最短路径算法具体实现
/*--------------------------函数原型声明 end----------------------*/

/*--------------------------函数具体实现 start----------------------*/

//功能：创建邻接矩阵图
void CreateMatrixGraph(MatrixGraph *G){
	char start, end;
	int i,j,k;
	int weight;
	printf("请输入生成图的类型（0：无向图， 1：有向图）：");
	fflush(stdin);
	scanf("%d", &G->GraphType);
	printf("请输入图的顶点数和边数：");
	fflush(stdin);
	scanf("%d %d", &G->VertexNum, &G->EndgeNum);
	for(i=0; i<G->VertexNum; i++)				//清空邻接矩阵
		for(j=0; j<G->VertexNum; j++)
			G->Endges[i][j] = MAXVALUE;
	printf("请输入各顶点信息：\n");
	for(i=0; i<G->VertexNum; i++){
		printf("请输入第%d个顶点的信息：", i+1);
		fflush(stdin);
		scanf("%c", &(G->Vertex[i]));
	}

	printf("请输入构成各边的两个顶点及权值：\n");			
	for(k=0; k<G->EndgeNum; k++){
		printf("请输入第%d条边的两个顶点及权值(用空格分隔)：", k+1);
		fflush(stdin);
		scanf("%c %c %d", &start, &end, &weight);
		for(i=0; start!=G->Vertex[i]; i++);
		for(j=0; end!=G->Vertex[j]; j++);
		G->Endges[i][j] = weight;
		if(G->GraphType == 0)
			G->Endges[j][i] = weight;
	}
	return;
}		

//功能：输出邻接矩阵图
void OutMatrix(MatrixGraph *G){
	int i, j;
	for(i=0; i<G->VertexNum; i++)
		printf("\t%c", G->Vertex[i]);
	printf("\n");

	for(i=0; i<G->VertexNum; i++){
		printf("%c\t", G->Vertex[i]);
		for(j=0; j<G->VertexNum; j++){
			if(G->Endges[i][j] == MAXVALUE)
				printf("∞\t");
			else
				printf("%d\t", G->Endges[i][j]);
		}
		printf("\n");
	}
	return;
}	

//功能：广度优先遍历主函数
void BFSTraverse(MatrixGraph *G){
	int i;
	for(i=0; i<G->VertexNum; i++)
		G->isTrav[i] =0;
	printf("广度优先遍历节点：");
	for(i=0; i<G->VertexNum; i++)
		if(!G->isTrav[i])
			BFSM(G, i);
	printf("\n");
}						

//功能：广度优先遍历具体实现
void BFSM(MatrixGraph *G, int k){
	int i,j;
	SeqQueue Q;
	QueueInit(&Q);
	G->isTrav[k] = 1;
	printf("->%c", G->Vertex[k]);
	QueueIn(&Q, k);

	while(!QueueIsEmpty(&Q)){
		QueueOut(&Q, &i);
		for(j=0; j<G->VertexNum; j++)
			if(G->Endges[i][j] != MAXVALUE && !G->isTrav[j]){
				G->isTrav[j] = 1;
				printf("->%c", G->Vertex[j]);
				QueueIn(&Q, j);
			}
	}
}

//功能：深度优先遍历主函数
void DFSTraverse(MatrixGraph *G){
	int i;
	for(i=0; i<G->VertexNum; i++)
		G->isTrav[i] = 0;
	printf("深度优先遍历节点：");
	for(i=0; i<G->VertexNum; i++)
		if(!G->isTrav[i])
			DFSM(G, i);
	printf("\n");
}

//功能：深度优先遍历具体实现(递归)
void DFSM(MatrixGraph *G, int k){
	int i,j;
	G->isTrav[k] = 1;
	printf("->%c",G->Vertex[k]);

	for(j=0; j<G->VertexNum; j++)
		if(G->Endges[k][j] != MAXVALUE && !G->isTrav[j])
			DFSM(G, j);
}		

//功能：Prim最小生成树算法具体实现
void Prim(MatrixGraph G){
	int i,j,k,min,sum=0;
	//Prim算法两个辅助数组
	int weight[VERTEX_MAX];			//保存tmpvertex中对应邻接边的权值
	char tmpvertex[VERTEX_MAX];		//保存邻接顶点信息

	//初始化：保存邻接矩阵中的一行数据，即0号顶点的邻接顶点、权值
	for(i=1; i<G.VertexNum; i++){
		weight[i] = G.Endges[0][i];
		if(weight[i] == MAXVALUE)
			tmpvertex[i] = NOADJ;			//非邻接点
		else
			tmpvertex[i] = G.Vertex[0];		//邻接点
	}
	tmpvertex[0] = USED;
	weight[0] = MAXVALUE;
	//生成最小生成树：即包含所有顶点
	for(i=1; i<G.VertexNum; i++){
		min = weight[0];
		k=i;
		for(j=1; j<G.VertexNum; j++)
			if(weight[j] < min && tmpvertex[j]!=0){
				min = weight[j];
				k=j;
			}
		sum +=min;
		printf("(%c,%c),", tmpvertex[k],G.Vertex[k]);
		tmpvertex[k] = USED;
		weight[k] = MAXVALUE;
		for(j=0; j<G.VertexNum; j++)
			if(G.Endges[k][j] < weight[j] && tmpvertex[j] != 0){
				weight[j] = G.Endges[k][j];
				tmpvertex[j] = G.Vertex[k];
			}
	}
	printf("\n最小生成树的总权值为：%d\n", sum);
}			

//功能：Dijkstra最短路径算法具体实现
void Dijkstra(MatrixGraph G){
	//Dijkstra算法辅助数组
	int weight[VERTEX_MAX];
	int path[VERTEX_MAX];
	int tmpvertex[VERTEX_MAX];
	int i,j,k,v0,min;
	printf("\n请输入源点的编号：");
	fflush(stdin);
	scanf("%d", &v0);
	v0--;				//编号减1（因为数组从0开始）
	//初始辅助数组
	for(i=0; i<G.VertexNum;i++){
		weight[i] = G.Endges[v0][i];	//保存最小权值
		if(weight[i]<MAXVALUE && weight[i] > 0)  //有效权值
			path[i] = v0;
		tmpvertex[i] =0;
	}
	tmpvertex[v0] = 1;		//将顶点v0添加到集合U中
	weight[v0] = 0;			//将源顶点的权值设为0
	for(i=0; i<G.VertexNum; i++){
		min = MAXVALUE;
		k = v0;
		for(j=0;j<G.VertexNum;j++)
			if(tmpvertex[j] == 0 && weight[j]<min){
				min = weight[j];
				k = j;
			}
		tmpvertex[k] = 1;
		for(j=0; j<G.VertexNum; j++)
			if(tmpvertex[j] == 0 && weight[k] + G.Endges[k][j] < weight[j]){
				weight[j] = weight[k] + G.Endges[k][j];
				path[j] = k;
			}
	}
	//输出结果
	printf("\n顶点%c到各顶点的最短路径为（终点 < 源点）:\n", G.Vertex[v0]);
	for(i=0; i<G.VertexNum; i++){
		if(tmpvertex[i]==1){
			k=i;
			while(k!=v0){
				printf("%c < ", G.Vertex[k]);
				k = path[k];		//上一个顶点
			}
			printf("%c\n", G.Vertex[k]);
		}
		else
			printf("%c<-%c:无路径\n", G.Vertex[i], G.Vertex[v0]);
	}
}										
/*--------------------------函数具体实现 end----------------------*/

3. 邻接表结构和操作定义

AdjListGraph.h

#define VERTEX_MAX 20

//功能：邻接表边的结构体
typedef struct edgeNode{
	int Vertex;			//顶点序号
	int weight;			//权值
	struct edgeNode *next;		//指向下一个顶点
}EdgeNode;

//功能：图的邻接表存储结构体
typedef struct{
	EdgeNode *AdjList[VERTEX_MAX];
	int VertexNum;
	int EndgeNum;
	int GraphType;
}ListGraph;

/*--------------------------函数原型声明 start----------------------*/
void CreateListGraph(ListGraph *G);	//功能：创建邻接表图
void OutList(ListGraph *G);		//功能：输出表图
/*--------------------------函数原型声明 end----------------------*/

/*--------------------------函数具体实现 start----------------------*/

//功能：创建表图
void CreateListGraph(ListGraph *G){
	int i, weight;
	int start, end;
	EdgeNode *s;
	printf("请输入生成图的类型（0：无向图， 1：有向图）：");
	fflush(stdin);
	scanf("%d", &G->GraphType);
	printf("请输入图的顶点数和边数：");
	fflush(stdin);
	scanf("%d %d", &G->VertexNum, &G->EndgeNum);
	for(i=0; i<G->VertexNum; i++)		//将图中各顶点指针清空
		G->AdjList[i] = NULL;
	for(i=1; i<=G->EndgeNum; i++){
		printf("请输入第%d条边的两个顶点及权值：", i);
		fflush(stdin);
		scanf("%d %d %d", &start, &end, &weight);
		s = (EdgeNode *)malloc(sizeof(EdgeNode));
		if(s==NULL){
			printf("申请内存失败！！");
			return ;
		}
		s->next = G->AdjList[start];		//头插法，将顶点插入到链表中
		s->weight = weight;
		s->Vertex = end;
		G->AdjList[start] = s;
		if(G->GraphType == 0){
			s = (EdgeNode *)malloc(sizeof(EdgeNode));
			if(s==NULL){
				printf("申请内存失败！！");
				return ;
			}
			s->next = G->AdjList[end];
			s->weight = weight;
			s->Vertex = start;
			G->AdjList[end] = s;
		}
	}
	return;
}	

//功能：输出表图
void OutList(ListGraph *G){
	int i;
	EdgeNode *s;
	for(i=1; i<=G->VertexNum; i++){
		printf("顶点%d", i);
		s = G->AdjList[i];
		while(s){
			printf("->%d(%d)",s->Vertex, s->weight);
			s = s->next;
		}
		printf("\n");
	}
	return;
}

/*--------------------------函数具体实现 end----------------------*/

4.图操作测试函数

GraphTest.cpp

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

#define QUEUE_MAXSIZE 30		//SeqQueue.h头文件中队列元素最大值

#include"AdjListGraph.h"
#include"AdjMatrixGraph.h"

int main(){
	int select;
	ListGraph LG;
	MatrixGraph G;
	do{
		printf("---------------------------\n");
		printf("1.用邻接矩阵法创建图       2.输出邻接矩阵\n");
		printf("3.用邻接表法创建图         4.输出邻接表\n");
		printf("5.广度优先遍历邻接矩阵图   6.深度优先遍历邻接矩阵图\n");
		printf("7.求邻接矩阵图的最小生成树 8.求邻接矩阵图指定顶点到其他顶点的最短路径\n");
		printf("0.退出\n");
		printf("请选择执行的操作序号：");
		//select = getch();
		fflush(stdin);
		scanf("%d", &select);
		switch(select){
			case 1:
				CreateMatrixGraph(&G);
				break;
			case 2:
				printf("邻接矩阵数据如下：\n");
				OutMatrix(&G);
				break;
			case 3:
				CreateListGraph(&LG);
				break;
			case 4:
				printf("邻接矩阵数据如下：\n");
				OutList(&LG);
				break;
			case 5:
				BFSTraverse(&G);
				break;
			case 6:
				DFSTraverse(&G);
				break;
			case 7:
				printf("构成最小生成树的边如下：\n");
				Prim(G);
				break;
			case 8:
				printf("最短路径算法开始执行：\n");
				Dijkstra(G);
				break;
		}
	}while(select != 0);
	system("pause");
	return 1;
}


西电小西
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图邻接矩阵算法
孤独的博客
11-16 3150
邻接矩阵比较好理解，这里就不记录了，主要是邻接表，比较难理解，       邻接表存储类型定义：   typedef struct ANode{ int adjvex; //该边的终点编号 struct ANode *nextarc; //指向下一条边的指针 InfoType weight; //该边的权值等信息} ArcNode; typedef struct Vnode{ Vertex data; //顶点信息 ArcNo
图的邻接矩阵表示的各种算法
11-05
图的邻接矩阵表示的迪杰斯特拉算法 普里姆算法 克鲁斯卡尔算法 c++实现 codeblocks编译通过
图的邻接矩阵算法
阿牛哥的博客
05-15 3054
无向图的邻接矩阵是关于左上右下对角线对称的，有向图不一定对称 先得理解矩阵描述的图，或者明白图的矩阵描述概念。 图的邻接矩阵存储结构 #define MAX 100 typedef struct{ char vexs[MAX]; //顶点表 int arc[MAX][MAX];//邻接矩阵，也就是边的关系表 int numVertexes,numEdges;//图中的定点数和边数 }MGaph; 根据邻接矩阵的定义，可得到建立图的邻接矩阵算法。 算法描述：首先得到图的顶点数和边数、然后按照顶.
图的邻接矩阵算法----（附完整调试代码）
玥玥的博客博客博客
08-13 6178
包含： 1.图的邻接矩阵的数据结构 2.图的初始化 3.图的创建 4.图的邻接矩阵的广度优先遍历算法   完整程序调试代码： #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define MaxVertexNum 100 #define INFINITY 65535 //#define MaxSize 10 typedef in...
图的邻接矩阵算法以及广度和深度遍历
卧龙居
10-21 1637
<br />果然，长期不碰数据结构后手都生了，写个小程序鼓捣了半天。其间一个幼稚的错误居然缠了很久，就是我设了MAX_VEXS_NUM为4时，我居然运行时考虑节点数为5和9的情况，而C++又不报数组越界的错误，所以对着莫名其妙的结果愣了半天。实在是太粗心了，以后要谨慎。<br />代码贴上来，每天看一下数据结构和算法。学再多框架都是虚的（当然，为了找工作，学框架是必要的，在J2EE如火如荼的今天），因为保不定哪天又有新的语言和框架出来。良好的数据结构和算法知识才是在编程武侠中笑傲江湖的内功心法。一定要注意！
数据结构学习--图的邻接矩阵和邻接表存储
06-25
图的存储方式主要有两种：邻接矩阵和邻接表。这两种存储方式各有优缺点，适用于不同的场景。 邻接矩阵是一种二维数组，其中的元素表示图中顶点之间的边。对于无向图，邻接矩阵是对称的，即如果顶点i和顶点j之间有一...
新建 DOC 文档_实现图的邻接矩阵和邻接表存储_doc_图的遍历算法_
10-01
领会图的两种主要存储结构、图基本运算算法和两种遍历算法设计内容：编写一个程序，设计带权图的邻接矩阵与邻接表的创建和输出运算，并在此基础上设计一个主程序完成如下功能：（1）建立如图所示的有向图G的邻接矩阵...
adjacency matrix.zip_adjacency matrix_matlab 邻接表_matlab邻接表_邻接矩阵
07-14
在计算机科学和图论中，邻接矩阵和邻接表是两种常见的表示图的数据结构。本文将详细讨论这两种数据结构，以及如何在MATLAB中进行转换。我们将专注于标题和描述中提到的MATLAB程序，该程序能够将邻接表转换为邻接矩阵...
数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历
10-07
本主题将深入探讨图的两种常见存储方式——邻接矩阵和邻接表，以及如何进行深度优先搜索（DFS）和广度优先搜索（BFS）遍历。 **邻接矩阵**是一种直观且简单的图存储方法。对于一个有n个顶点的图，邻接矩阵是一个n×...
图的邻接矩阵和邻接表的建立与输出.docx
07-12
图的邻接矩阵和邻接表的建立与输出 图的邻接矩阵和邻接表是图论中两个重要的数据结构，将图的信息存储在矩阵或表中以便于图的处理和计算。 在《数据结构》中，严蔚敏教授详细讲解了图的邻接矩阵和邻接表的建立与...
图的邻接矩阵和邻接表表示的各种算法
11-05
图的邻接表 邻接矩阵表示的迪杰斯特拉算法 普里姆算法 克鲁斯卡尔算法 用c++实现 codeblocks编译通过
30 | 图的表示：如何存储微博、微信等社交网络中的好友关系？
liyf2的博客
10-26 903
微博、微信、LinkedIn 这些社交软件我想你肯定都玩过吧。在微博中，两个人可以互相关注；在微信中，两个人可以互加好友。那你知道，如何存储微博、微信等这些社交网络的好友关系吗？ 这就要用到我们今天要讲的这种数据结构：图。实际上，涉及图的算法有很多，也非常复杂，比如图的搜索、最短路径、最小生成树、二分图等等。我们今天聚焦在图存储这一方面，后面会分好几节来依次讲解图相关的算法。 如何理解“图”？ 我们前面讲过了树这种非线性表数据结构，今天我们要讲另一种非线性表数据结构，图（Graph）。和树比起来，这是一种更
图（邻接矩阵实现）（C++实现）
qq_39559641的博客
04-07 5146
一、实验要求 设计图（网）的邻接矩阵，编写算法实现下列问题的求解。 1．打印出图（网）的两种遍历序。 实验测试数据基本要求： 第一组数据： udg8.grp 第二组数据： udg115.grp 第三组数据： dg6.grp 2．求给定图中的边（或弧）的数目。 实验测试数据基本要求： 第一组数据： udg8.grp 第二组数据： udg115.grp 3．...
中级算法题(图的邻接矩阵+Dijkstra算法)
sunnygao的博客
08-02 481
文章目录题目：743. 网络延迟时间图的实战一、猜想：dfs是否可行二、图的复习2.1邻接表和邻接矩阵2.2迪杰斯特拉算法三、实战代码3.1邻接矩阵+迪杰斯特拉算法 题目：743. 网络延迟时间 743. 网络延迟时间 图的实战 ​ 这道题是找一条最长时间的路径。 一、猜想：dfs是否可行 ​ 把它理解为一个有向图，找出时间最长路径，但是有一个问题，题目给出的数据结构是数组，没有二叉树和图的关系结构，所以在dfs时会碰到如何用代码实现深度搜索各条路径的问题。 二、图的复习 ​ 图分为无向图和有向图。 2.1
[算法]图(邻接矩阵)的深度遍历
老梁的专栏
06-14 1593
package com.FeeLang;import java.util.Scanner;class ArcNode{ int adjvex; ArcNode next;}class VertexNode{ char vertex; ArcNode firstedge;}public class Graph { public static void ma
【C++】图(邻接矩阵实现+必要算法)
taoxing
07-12 5690
文章目录一.基础知识二.分步实现代码三.完整代码四.结果展示 一.基础知识 说起图来大家都很容易理解，图就是由若干顶点以及连接顶点的边所构成的图形。如下图所示： 接下来我们介绍一些图中的基本概念： ∙\bullet∙ 顶点（Vertex）：自面意思，比如说上图的1、2、3、4、5、6 ∙\bullet∙ 边（edge）：自面意思，连接两个顶点的线条 ∙\bullet∙ 权重（weight）：每条边上所赋的一个值 ∙\bullet∙ 无向图：顶点之间没有连接方向，我们重点讨论的就是无向图。（拓扑排序
52-图的邻接矩阵存储结构及算法
网络安全
07-17 8059
1. 图的存储结构   通常我们要根据图的逻辑结构来设计图的存储结构来 存储每个顶点的信息，存储每条边的信息。图的存储结构有以下两种：   1. 邻接矩阵存储方法   2.邻接表存储方法 2. 邻接矩阵存储方法   邻接矩阵是表示顶点之间相邻关系的矩阵。设G = （V , E）是具有n（n &amp;amp;amp;amp;amp;amp;amp;amp;gt; 0）个顶点的图，顶点的编号依次为0 ~ n-1。G的邻接矩阵A是n阶方阵，其定义如下...
图知识总结（二）：图的邻接矩阵存储方法及相关算法设计
最新发布
STRANGEX-03的博客
07-15 1944
设 G = ( V, E ) 是含有n（n＞0）个顶点的图，各顶点的编号为 0~(n-1) ，则 G 的邻接矩阵数组 A 是 n 阶方阵，其定义如下：对于无向图：对于有向图：以下算法设计中，默认MatGraph中VertexType类型的vexs数组元素顶点编号从0开始，即与存储编号相同。
JAVA实现图的基本操作——生成邻接表结构的图、输出邻接矩阵、深度优先遍历
Lilyの博客 ٩(❛ัᴗ❛ั)
04-25 2881
初始化图，即初始化所有的边和顶点。 创建图，即按照邻接表的结构创建图，这里根据用户的输入决定创建的是无向图还是有向图。 输出邻接矩阵，根据图的数据结构定义的标志位来输出该图的邻接矩阵。 输出深度优先遍历结果，即按照深度优先的方式来遍历图。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值