邻接表与逆邻接表（数组实现）

最新推荐文章于 2025-07-25 13:53:59 发布

ygqwan

最新推荐文章于 2025-07-25 13:53:59 发布

阅读量6.4k

点赞数

CC 4.0 BY-SA版权

分类专栏：数据结构模板

本文链接：https://blog.youkuaiyun.com/ygqwan/article/details/8908991

数据结构同时被 2 个专栏收录

13 篇文章

订阅专栏

模板

11 篇文章

订阅专栏

本文介绍了邻接表的概念，通过数组实现邻接表，解释了next数组如何存储弧头信息，并强调了每条边只能被指向一次。此外，还提到了逆邻接表的实现，通过pre数组记录逆边序号。示例中展示了如何使用邻接表和逆邻接表解决图论问题。

配一张图：

比如H[1] 下面有四个数（-1也是的） -1，0， 3， 5；

就说明A[0] 是点 1 的弧头， A[3] 是 1 的弧头， A[5] 也是1 的弧头；但是一个数组的一个小单元之能存一个数怎么办呢，这个时候就是next的用处了；

我们让next[5] 指向数组下标3就可以了，让next[3]指向数组下标0，同理，让next[1] 指向一个数-1，就代表没法在传递了，就是没有其他边的意思

所以可以看到next数组（就是图上的大N），上面的箭头，意思懂了吧；

H数组下面的几个数都是下标，看到了吗，没有一个重复的，这是必然的，因为每一条边只能被指向一次

引用头文件：string.h

使用宏定义：#define CLR(arr,val) memset(arr,val,sizeof(arr))

下面弧头弧尾说反了，自行纠正

使用说明：每次使用前必须要先调用Init()函数，AddEdge()用来加边。

#include <iostream> 
#include <iostream>
#include <algorithm>
#include <queue>
#include <malloc.h>
#include <string.h>
using namespace std;
const int MAXN=1001;
#define CLR(arr,val) memset(arr,val,sizeof(arr));
template<int MaxV,int MaxE>  // 顶点数，边数
struct Graph
{
	void Init(){
		CLR(Head,-1);
		top = 0;
	}
	void AddEdge(int u,int v,int len){
		Next[top] = Head[u];   //利用next[top]保存u的【第一条弧节点】在num数组中的下标 
		Head[u] = top;		//给新的弧【新的第一条弧节点】保存在num数组中的下标
		Num[top] = v;
		Len[top] = len;
		top ++;
	}
	int Head[MaxV],Num[MaxE],Next[MaxE],top;
	int Len[MaxE]; // 权值
	/*
		Head: Head的下标永远为u，因为Head是保存的弧. Head[u] = t1 意为从弧头 u 出发 可以到达点 t1 ；
			  那么通常 u 还可以到达点t2，t3，t4 ...怎么办呢？那么我们可以通过 next[t1] 找到 num[next[t1]] 找			  到点 t2 ；同时再由num[next[next[t1]]]找到 t3 ......所以next的作用就是帮助当先点找到下一个点				 （因为next数组存的是num数组的下标）
		Num : 记录的是弧尾（所有的弧尾都保存在这里面）
		Len : 记录 u 到 v 的权值
		Next: 记录的由弧头 u （寻找的过程被不断更新） 出发 能够找到的下一个（弧尾）点
		top : 就是边的下标（有m条边，top就是0 —— m-1）

		总结：
			1.数组Head和next都是存的数组num的下标，也就是存的弧尾的的下标，那么就可以通过Head[u] 最先找到一			2.个和 u 相连的num 的数组下标Head[u],那么最先找到的点就是num[Head[u]];然后再接着找和 u 相连的点，			  通过next数组可以确定下一个点...
			3.num是存所有的弧尾（一个弧尾就意味着有一条边）
			4.这种写法是后添加的边先访问
	*/
};
const int MaxV = 1005,MaxE = 1005;
Graph<MaxV,MaxE> g;
void Search(int curPoint)
{
	for(int i = g.Head[curPoint] ; i != -1 ; i = g.Next[i] ){  // 遍历从 curPoint 出发的边
		cout << curPoint << " --> " << g.Num[i] << "  == " << g.Len[i] << endl;
	}
}
int main()
{
	
	g.Init();  // 必须先初始化
	g.AddEdge(1,2,10);
	g.AddEdge(1,5,23);
	Search(1);
}

下面就用一个例题试试：

题目链接：http://acm.nyist.net/JudgeOnline/problem.php?pid=115

#include <iostream> 
#include <iostream>
#include <algorithm>
#include <queue>
#include <malloc.h>
#include <string.h>
using namespace std;
const int MAXN=1001;
#define CLR(arr,val) memset(arr,val,sizeof(arr));
template<int MaxV,int MaxE>  // 顶点数，边数
struct Graph
{
	void Init(){
		CLR(Head,-1);
		top = 0;
	}
	void AddEdge(int u,int v,int len){
		Next[top] = Head[u];    
		Head[u] = top;
		Num[top] = v;
		Len[top] = len;
		top ++;
	}
	int Head[MaxV],Num[MaxE],Next[MaxE],top;
	int Len[MaxE]; // 权值
	/*
		Head: Head的下标永远为u，因为Head是保存的弧头. Head[u] = t1 意为从弧头 u 出发 可以到达点 t1 ；
			  那么通常 u 还可以到达点t2，t3，t4 ...怎么办呢？那么我们可以通过 next[t1] 找到 num[next[t1]] 找			  到点 t2 ；同时再由num[next[next[t1]]]找到 t3 ......所以next的作用就是帮助当先点找到下一个点				 （因为next数组存的是num数组的下标）
		Num : 记录的是弧尾（所有的弧尾都保存在这里面）
		Len : 记录 u 到 v 的权值
		Next: 记录的由弧头 u （寻找的过程被不断更新） 出发 能够找到的下一个（弧尾）点
		top : 就是边的下标（有m条边，top就是0 —— m-1）

		总结：
			1.数组Head和next都是存的数组num的下标，也就是存的弧尾的的下标，那么就可以通过Head[u] 最先找到一			2.个和 u 相连的num 的数组下标Head[u],那么最先找到的点就是num[Head[u]];然后再接着找和 u 相连的点，			  通过next数组可以确定下一个点...
			3.num是存所有的弧尾（一个弧尾就意味着有一条边）
			4.这种写法是后添加的边先访问
	*/
};
const int Max = 1005,MaxE = 100005;
struct Node
{
	Node(){}
	Node(int len,int num):len(len),num(num){}
	int len,num;
};
bool operator<(const Node& n1,const Node& n2)
{
	return n1.len>n2.len;
}
Graph<Max,MaxE> g;
int Dis[Max],INF=0x3f3f3f3f;

void Dijkstra(int s,int v)
{
	fill(Dis,Dis+v,INF);
	priority_queue<Node> q;
	Dis[s]=0;
	q.push(Node(0,s));
	Node cur;
	while(!q.empty())
	{
		cur=q.top();q.pop();
		if(cur.len!=Dis[cur.num]) continue;
		for(int i=g.Head[cur.num];i!=-1;i=g.Next[i])
		{
			if(cur.len+g.Len[i]<Dis[g.Num[i]])
			{
				Dis[g.Num[i]]=cur.len+g.Len[i];
				q.push(Node(Dis[g.Num[i]],g.Num[i]));
			}
		}
	}
}
int main()
{
	int T;
	cin >> T;
	while( T --)
	{
		g.Init();
		int n,m,p,q;
		cin >> n >> m >> p >> q;
		bool have[Max];
		CLR(have,false);
		for(int i = 0,tmp ; i < n ;i ++)
			cin >> tmp,have[tmp] = true;
		for(int i = 0 ; i < p ;i ++)
		{
			int u,v,len;
			cin >> u >> v >> len ;
			g.AddEdge(u,v,len);
			g.AddEdge(v,u,len);
		}
		Dijkstra(q,m);
		int ans =  INF;
		for(int i = 0 ;  i <= m ; i++)
		{
			//cout << Dis[i] << endl;
			if(have[i] && Dis[i] < ans)
				ans = Dis[i];
		}
		cout << ans << endl;
	}
	return 0 ;
}

逆邻接表：

逆邻接表就是同时加两条边，用一个pre数组记录逆边序号

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>

#define CLR(a, val) memset(a, val, sizeof(a))
#pragma warning(disable:4996)

using namespace std;

template<int MaxV, int MaxE>
struct Graph
{
	void init()
	{
		top = 0;
		CLR(head, -1);
	}
	void addEdge(int u, int v, int w)
	{
		next[top] = head[u];
		head[u] = top;
		arc[top] = v;
		len[top] = w;
		pre[top] = top + 1;
		top++;

		next[top] = head[v];
		head[v] = top;
		arc[top] = u;
		len[top] = 0;
		pre[top] = top - 1;
		top++;
	}
	int top;
	int head[MaxV], next[MaxE], arc[MaxE], len[MaxE], pre[MaxE];
};

const int MaxV = 100;
const int MaxE = 1000;

int vexNum, edgeNum;
int s, t;
Graph<MaxV, MaxE> g;

void debug()
{
	cout << "--------前向边----------" << endl;
	for(int i = 1; i <= vexNum; i++)
	{
		cout << i << "  :";
		for(int j = g.head[i]; j != -1; j = g.next[j]) //前向边
		{
			if(j % 2 == 0)
				cout << g.arc[j] << " ";
		}
		cout << endl;
	}
	cout << "--------后向边---------" << endl;
	for(int i = 1; i <= vexNum; i++)  //后向边
	{
		cout << i << " :";
		for(int j = g.head[i]; j != -1; j = g.next[j])
		{
			if(j % 2 == 1)
				cout << g.arc[j] << " ";
		}
		cout << endl;
	}
}

int main()
{
	//freopen("data_in.txt", "r", stdin);
	g.init();
	int u, v, w;
	cin >> vexNum >> edgeNum;
	for(int i = 0; i < edgeNum; i++)
	{
		cin >> u >> v >> w;
		g.addEdge(u, v, w);
	}
	cin >> s >> t;
	debug();
	return 0;
}

输入：

6 8
1 2 4
1 3 3
2 5 3
2 3 1
3 4 4
2 4 5
5 6 4
4 6 2
1 6