图的常见存储结构

图的存储结构

邻接矩阵

邻接矩阵的表示方式为一个拥有两个维度的数组。其表示方法为

define N 1000+5
int a[N][N]
a[i][j]=1；//其从i到j有边，其权值为1。一般当图是没有权重的
		  //就视为其权重为1

前向星

前向星和邻接矩阵的不同是，它使用主要存储边的方式来存储整个图的信息。其是用一个数据结构来定义而成

int head[maxn]//存储每一个边的起始位置
struct node{
	int from;
	int to;
	int val;
}
node edge[maxn];

前向星是按照边的起点来进行排序，当边的起点相同时就按照边的终点来排序，当边的起点和终点都相同时，就按照此边的权值来排序，其比较代码如下：

bool cmp(node a,node b){
	if(a.from==b.fron&&a.to==b.to) return a.val<b.val;
	if(a.from==b.from) return a.to<b.to;
	return a.from<b.from;
}

其读入数据的代码如下：

int n,m;
cin>>n>>m;
for(int i=0;i<m;i++) {cin>>edge[i].from>>edge[i].to>>edge[i].val;}
sort(edge,edge+m,cmp);
memset(head,-1,sizeof(head));
head[edge[0].from]=0;
for(int i=1;i<m;i++){
if(edge[i].from!=edge[i-1].from) head[edge[i].from]=i;

遍历代码：

for(int i=1;i<=n;i++){
	for(int k=head[i];edge[k].from==i&&k<m;k++){
		cout<<edge[k].from<<' '<<edge[i].to<<' '<<edge[i].val;
	}
}	

其时间复杂度多取决于排序算法，所以为O（mlogm）其空间复杂度为O（m+n）。前向星有很优点，但是其不可以直接判断某两点之间是否有边。

邻接表

邻接表就是视为每一个边为一个队列，如果有和这个边相连的顶点，则直接帮这个顶点入队到这个边对应的队列里。其的数据单元也是用自定义的数据结构存储的。

struct edgenode{
	int to;
	int val;
	edgenode * next;
}
struct vexnode{
	int from;
	edgenode * front;
}
vexnode vex[maxn];

其存储信息：

cin>>i>>j>>w;
edgenode * p=new edgenode;
p->to=j;
p->val=w;
p->next=vex[i].front;
vex[i].front=p;

遍历代码：

for(int i=1;i<=n;i++){
	for(int edgenode * k=vex[i].front;k!=NULL;k=k->next){
		cout<<i<<' '<<k->to<<' '<<k->val<<endl;
	}
}

当然，我们可以用ＳＴＬ库里的ｖｅｃｔｏｒ模拟链表来实现
链表的创建：

ｖｅｃｔｏｒ＜ｖｅｃｔｏｒ＜ｐａｉｒ＜ｉｎｔ，ｉｎｔ＞＞＞ｇ；
//这里创建了一个ｖｅｃｔｏｒ套ｖｅｃｔｏｒ的数组，这个数组在使用
//的时候需要定义下：ｇ＝ｖｅｃｔｏｒ＜ｖｅｃｔｏｒ＜ｐａｉｒ＜ｉｎｔ，ｉｎｔ＞＞＞（ｎ）；放可是直接使用

其存储信息：

int i,j,w;
cin>>i>>j>>w;
g[i].push_back(make_pair(j,w));
g[j],push_back(make_pair(i,w));

其遍历代码：

for(int i=1;i<=n;i++){
	for(pair<int,int> to:g[x]){
		cout<<x<<' '<<to.frist<<' '<<to.second<<endl;
	}
}

链式前向星

链式前向星又叫静态链表，是提高其构造效率来创造出来的一种高效的数据结构。

int head[maxn];
struct edgenode{
	int to;
	int w;
	int next;
}
edgenode edge[maxn];

信息存储：

int i,j,w;
cin>>i>>j>>w;
edge[k].to=j;//这里的k代表的是这是你存储的第k条边
edge[k].w=w;
edge[k].next=head[i];
head[i]=k;

遍历代码：

for(int i=1;i<=n;i++){
	for(k=head[i];k!=-1;k=edge[k].next){
		cout<<i<<' '<<edge[k].to<<' '<<edge[k].w<<endl;
	}
}