图的操作和l邻接矩阵存储

/*

1.图是由顶点集合及顶点之间的关系集合组成的一种数据结构。图的定义:G=(V,E)

2.顶点和边:图中的结点一般称作顶点,顶点与顶点相关联称作遍

3.完全图:在n个顶点的无向图中,若有n(n-1)/2条边,即任意两个顶点之间有且只有一条边,则称此图

为无向完全图;在n个顶点的右向图中,若有n(n-1)条边,即任意两个顶点之间有且只有方向相反的2条边,

则称此图为有向完全图。

4.顶点的度:顶点的度=出度+入度

5.连通图和强连通图:

在无向图中,若从顶点vi到顶点vj有路径,则称顶点vi和顶点vj是连通的。如果图中任意一对顶点都是连通的,则称

该图是连通图。

在有向图中,若任意一对顶点vi和顶点vj(vi!=vj)都存在路径,则称图G是强连通图。

6.生成树:一个连通图的最小连通子图称作该图的生成树。有n个顶点的连通图的生成树有n个顶点和n-1条边。

7.简单路径和回路:若路径上各个顶点v1,v2,v3....vm,互不重复,则称这样的路径为简单路径;若路径第一个顶点v1与最后一个顶点

vm重合,则这样的路径为回路或环路

8.图的存储结构主要是图中边的存储结构。图的存储结构主要有邻接矩阵和邻接表2种。

当图中顶点数目较小且边较多时,采用图的邻接矩阵存储结构效率较高,即对稠密矩阵最好采用二维数组存储;当图中顶点数目较大且边的数目远远小于

相同顶点的完全图的边数时,采用图的邻街表存储结构效率较高,即对希疏矩阵,最好采用行指针数组结构的三元组链表。

*/

//邻接矩阵存储结构下图操作的实现
#include<stdio.h>
#define MaxSize 100        //定义元素的大小
typedef char DataType;        //定义一个类型
#define MaxVertices 10       //定义顶点的最大值
#define MaxWeight 10000        //定义无穷大的具体值

typedef struct{     //定义一个结构体
  DataType list[MaxSize];
  int size;             //结构体元素的大小
}SeqList;                 //结构体的对象

typedef struct{

	SeqList Vertices;//存放顶点的顺序表
	int edge[MaxVertices][MaxVertices];//存放边的邻接矩阵
	int numOfEdges;//边的条数
}AdjMGraph;

typedef struct{

	int row;//行下标
	int col;//列下标
	int weight;//权值
}RowColWeight;//边信息结构体

//初始化
void  initiate(SeqList *L){
      L->size=0;//定义初始化元素个数
}

//求当前元素的个数
int getLength(SeqList L){

	return L.size;//返回长度
}

//插入数据元素
int insertData(SeqList *L,int i,DataType x){
	//在顺序表L的第i(0<=i<=size)个位置前插入数据元素x
	//插入成功返回1,出人失败返回0
   int j;
   if(L->size>=MaxSize){
      printf("顺序表已满,无法插入!!\n");
	  return 0;
   }else if(i<0||i>L->size){
      printf("插入的位置不合法,不在指定的范围,参数i不合法!\n");
	  return 0;
   }else{
      //从后向前一致移动数据,为插入做准备
	   for(j=L->size;j>i;j--){
	         L->list[j]=L->list[j-1];
	   }
       L->list[i]=x;
	   L->size++;
	   return 1;
   }
}

//删除数据
int deleteData(SeqList *L,int i,DataType *x){
    //删除顺序表中位置为i的数据i>=0&&i<=size-1,把数据保存到x中
	//删除成功返回1,否则返回0
	int j;
	if(L->size<=0){
	    printf("顺序表已空无数据元素可删!\n");
		return 0;
	}else if(i<0||i>L->size-1){
	    printf("参数i不合法,不能删除!\n");
		return 0;
	}else{
		*x=L->list[i];
		for(j=i+1;j<=L->size-1;j++){//从前往后一次前移
		     L->list[j-1]=L->list[j];
		}
		L->size--;//数据元素减一
		return 1;
	}
}

//取出数据元素
int getData(SeqList L,int i,DataType *x){
    if(i<0||i>L.size-1){
		printf("参数i不合法,不能删除!\n");
		return 0;
	}else{
	    *x=L.list[i];
		return 1;
	}
}

//初始化有n个顶点的顺序表和邻接矩阵
void InitiateG(AdjMGraph *g,int n){

	//初始化
	int i,j;

	for(i=0;i<n;i++){

		for(j=0;j<n;j++){

			if(i==j){

				g->edge[i][j]=0;
			}else{

				g->edge[i][j]=MaxWeight;//MaxWeight表示无穷大
			}
		}
	}

	g->numOfEdges=0;//边的条数置为0
	initiate(&g->Vertices);//顺序表初始化

}

//插入顶点
void InsertVertex(AdjMGraph *g,DataType vertex){
//在图G中插入顶点vertex

	insertData(&g->Vertices,g->Vertices.size,vertex);//顺序表尾插入

}

//插入边
void InsertEdge(AdjMGraph *g,int v1,int v2,int weight){
//在图中插入边<v1,v2>,边<v1,v2>的权为weight
	if(v1<0||v1>=g->Vertices.size||v2<0||v2>=g->Vertices.size){

		printf("参数v1或v2越界出错!!!\n");
		return ;
	}

	g->edge[v1][v2]=weight;
	printf("(%d)",g->edge[v1][v2]);
	g->numOfEdges++;

}

//删除边
void DeleteEdge(AdjMGraph *g,int v1,int v2){

	//在G图中删除边<v1,v2>
	if(v1<0||v1>=g->Vertices.size||v2<0||v2>=g->Vertices.size){

		printf("参数v1或v2越界出错!!!\n");
		return ;
	}

	if(g->edge[v1][v2]==MaxWeight||v1==v2){

		printf("该边不存在!!!\n");
		return;
	}

	g->edge[v1][v2]=MaxWeight;
	g->numOfEdges--;

}

//取第一个邻接顶点
int GetFirstVex(AdjMGraph g,int v){
//在图G中寻找序号为v的顶点的第一个邻接顶点
	//如果这样的顶点存在,则返回该邻接顶点的序号,否则返回-1
	int col;
	if(v<0||v>=g.Vertices.size){

		printf("参数v1越界出错!!!\n");
		return -1;
	}

	for(col=0;col<g.Vertices.size;col++){

		if(g.edge[v][col]>0&&g.edge[v][col]<MaxWeight){

			return col;
		}
	}

	return -1;

}

//取下一个邻接顶点
int GetNextVex(AdjMGraph g,int v1,int v2){
//在图中寻找v1顶点的邻接顶点v2的下一个邻接顶点
	//如果这样的邻接顶点存在,则返回该邻接顶点的序号;否则返回-1
	//v1和v2都是相应的顶点的序号
	int col;
	if(v1<0||v1>g.Vertices.size||v2<0||v2>=g.Vertices.size){
		printf("参数v1或v2越界出错!!!\n");
		return -1;
	}

	for(col=v2+1;col<g.Vertices.size;col++){

		if(g.edge[v1][col]>0&&g.edge[v1][col]<MaxWeight){

			return col;
		}
	}

	return -1;

}

void CreatGraph(AdjMGraph *g,DataType V[],int n,RowColWeight E[],int e){
//在图中插入n个顶点信息V和e条边信息E
	int i,k;
	InitiateG(g,n);//d顶点顺序表初始化
	for(i=0;i<n;i++){

		InsertVertex(g,V[i]);//插入顶点
	}
	for(k=0;k<e;k++){
	     printf("%d ",E[k].weight);
		InsertEdge(g,E[k].row,E[k].col,E[k].weight);//插入边
	}
}

void main(){

	AdjMGraph g1;
	DataType a[]={'A','B','C','D','E'};
	RowColWeight rcw[]={{0,1,10},{0,4,20},{1,3,30},{2,1,40},{3,2,50}};
	int n=5,e=5;
	int i,j;
	CreatGraph(&g1,a,n,rcw,e);//创建图
    DeleteEdge(&g1,0,4);//删除边<0,4>

	printf("顶点集合为:");
	for(i=0;i<g1.Vertices.size;i++){

		printf("%c  ",g1.Vertices.list[i]);
	}
	printf("\n");
	printf("权值集合为:\n");
	for(i=0;i<g1.Vertices.size;i++){
		for(j=0;j<g1.Vertices.size;j++){

			printf("%5d  ",g1.edge[i][j]);
		}
		printf("\n");
	}

}

时间: 2024-10-29 19:07:47

图的操作和l邻接矩阵存储的相关文章

java 数据结构 图中使用的一些常用算法 图的存储结构 邻接矩阵:图的邻接矩阵存储方式是用两个数组来标示图。一个一位数组存储图顶点的信息,一个二维数组(称为邻接矩阵)存储图中边或者弧的信息。 设图G有n个顶点,则邻接矩阵是一个n*n的方阵,定义为: 实例如下,左图是一个无向图。右图是邻接矩阵表示:

以下内容主要来自大话数据结构之中,部分内容参考互联网中其他前辈的博客. 图的定义 图是由顶点的有穷非空集合和顶点之间边的集合组成,通过表示为G(V,E),其中,G标示一个图,V是图G中顶点的集合,E是图G中边的集合. 无边图:若顶点Vi到Vj之间的边没有方向,则称这条边为无项边(Edge),用序偶对(Vi,Vj)标示. 对于下图无向图G1来说,G1=(V1, {E1}),其中顶点集合V1={A,B,C,D}:边集合E1={(A,B),(B,C),(C,D),(D,A),(A,C)}: 有向图:若

图的邻接矩阵存储

邻接表的构造与邻接矩阵完全不同,同学们应该发现了,邻接表的的结构更像是由几个链表构成的. 在构造邻接表时,我们的确会借助链表的结构.对图中每个顶点的信息,我们都会分别使用一个链表来进行存储. 因此,我们需要初始化一个有 n 个元素的链表数组,n 为图中顶点数量. 我们要在邻接表中存储的图的信息,实际上就是顶点之间存在的有向边. 当从顶点 a 到顶点 b 存在一条有向边时,我们只需要在头结点为 a 的链表后插入一个结点 b. 值得注意的是,当一条边是从顶点 b 到顶点 a 时,我们同样需要在以 b

基于邻接矩阵存储的图的深度优先遍历和广度优先遍历

图的存储结构相比较线性表与树来说就复杂很多,对于线性表来说,是一对一的关系,所以用数组或者链表均可简单存放.树结构是一对多的关系,所以我们要将数组和链表的特性结合在一起才能更好的存放. 那么我们的图,是多对多的情况,另外图上的任何一个顶点都可以被看作是第一个顶点,任一顶点的邻接点之间也不存在次序关系. 仔细观察以下几张图,然后深刻领悟一下: 因为任意两个顶点之间都可能存在联系,因此无法以数据元素在内存中的物理位置来表示元素之间的关系(内存物理位置是线性的,图的元素关系是平面的). 如果用多重链表

数据结构实践——操作用邻接表存储的图

本文是针对[数据结构基础系列(7):图]的实践. [项目 - 操作用邻接表存储的图] 假设图G采用邻接表存储,分别设计实现以下要求的算法: (1)输出出图G中每个顶点的出度: (2)求出图G中出度最大的一个顶点,输出该顶点编号: (3)计算图G中出度为0的顶点数: (4)判断图G中是否存在边<i,j>. 利用下图作为测试用图,输出结果. 提示:(1)分别设计函数实现算法:(2)不要全部实现完再测试,而是实现一个,测试一个:(3)请利用图算法库. [参考解答] #include <stdi

图的邻接矩阵存储数据结构--自己写数据结构

头文件graph.h #ifndef _GRAPH_H_ #define _GRAPH_H_ #define MAX_VER 100 #define ENDLESS 65535 typedef char VertexType; typedef int EdgeType; typedef struct _Graph { VertexType ver[MAX_VER]; EdgeType edge[MAX_VER][MAX_VER]; int num_ver,num_edge; }Graph,*pG

邻接矩阵存储的图

<span style="font-size:24px;">java实现用邻接矩阵(相邻矩阵)实现图,缺点是矩阵中大量的0元素会耗费大量的存储空间</span> public class Graph { final int MAX_VERTEX = 10;// 最多10个顶点 Vertex[] vertex;// 顶点数组 int[][] adjacency;// 邻接矩阵 int numOfVertex;// 当前图中顶点的数量 public Graph()

PTA 邻接矩阵存储图的深度优先遍历

6-1 邻接矩阵存储图的深度优先遍历(20 分) 试实现邻接矩阵存储图的深度优先遍历. 函数接口定义: void DFS( MGraph Graph, Vertex V, void (*Visit)(Vertex) ); 其中MGraph是邻接矩阵存储的图,定义如下: typedef struct GNode *PtrToGNode; struct GNode{ int Nv; /* 顶点数 */ int Ne; /* 边数 */ WeightType G[MaxVertexNum][MaxVe

DS图—图的邻接矩阵存储及度计算

题目描述 假设图用邻接矩阵存储.输入图的顶点信息和边信息,完成邻接矩阵的设置,并计算各顶点的入度.出度和度,并输出图中的孤立点(度为0的顶点) --程序要求-- 若使用C++只能include一个头文件iostream:若使用C语言只能include一个头文件stdio 程序中若include多过一个头文件,不看代码,作0分处理 不允许使用第三方对象或函数实现本题的要求 输入 测试次数T,每组测试数据格式如下: 图类型  顶点数 (D—有向图,U—无向图) 顶点信息 边数 每行一条边(顶点1 顶

练习6.1 邻接矩阵存储图的深度优先遍历 (20分)

试实现邻接矩阵存储图的深度优先遍历. 函数接口定义: void DFS( MGraph Graph, Vertex V, void (*Visit)(Vertex) ); 其中MGraph是邻接矩阵存储的图,定义如下: typedef struct GNode *PtrToGNode; struct GNode{ int Nv; /* 顶点数 */ int Ne; /* 边数 */ WeightType G[MaxVertexNum][MaxVertexNum]; /* 邻接矩阵 */ }; t