邻接表的实现（有向邻接表）、（无向邻接表），基于C++

已于 2024-07-26 10:53:01 修改
阅读量5.7k 收藏 40
点赞数 4
分类专栏： 数据结构与算法 文章标签： c++ 链表 数据结构
于 2022-02-24 16:12:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40059236/article/details/123114056
版权
本文介绍了如何使用C++实现邻接表数据结构，包括有向和无向图的邻接表。邻接表相较于邻接矩阵在存储空间上更节省，特别适合边数相对顶点较少的图。文章通过代码展示了具体的实现，并给出了运行示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

邻接表 

邻接矩阵的实现请看这里

是不错的一种图存储结构，但是，对于边数相对顶点较少的图，这种结构存在对存储空间的极大浪费。因此，找到一种数组与链表相结合的存储方法称为邻接表。
邻接表的处理方法是这样的：

  • （1）图中顶点用一个一维数组存储，当然，顶点也可以用单链表来存储，不过，数组可以较容易的读取顶点的信息，更加方便。
  • （2）图中每个顶点vi的所有邻接点构成一个线性表，由于邻接点的个数不定，所以，用单链表存储，无向图称为顶点vi的边表，有向图则称为顶点vi作为弧尾的出边表。
    例如，下图就是一个无向图的邻接表的结构。

从图中可以看出，顶点表的各个结点由data和firstedge两个域表示，data是数据域，存储顶点的信息，firstedge是指针域，指向边表的第一个结点，即此顶点的第一个邻接点。边表结点由adjvex和next两个域组成。adjvex是邻接点域，存储某顶点的邻接点在顶点表中的下标，next则存储指向边表中下一个结点的指针。
对于带权值的网图，可以在边表结点定义中再增加一个weight的数据域，存储权值信息即可。如下图所示。 

代码实现邻接表（有向邻接表图） 基于C++

/**
 * C++: 邻接表图
 *
 * @author lph
 * 
 */

#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;

#define MAX 100
// 邻接表
class ListDG {
private: // 内部类
	// 邻接表中表对应的链表顶点
	class ENode {
	public:
		int ivex;			// 该边所指向的顶点的位置
		ENode* nextEdge;	// 指向下一条弧的指针
	};

	// 邻接表中表的顶点
	class VNode {
	public:
		char data;			//顶点信息
		ENode* firstEdge;	//指向第一条依赖该顶点的弧
	};

private: // 私有成员
	int mVexNum;			//图的顶点的数目
	int mEdgNum;			//图的边的数目
	VNode mVexs[MAX];		//用一维数组来存储邻接表的顶点

public:
	// 创建邻接表对应的图（自己输入）
	ListDG();
	// 创建邻接表对应的图（用已经提供的数据）
	ListDG(char vexs[], int vlen, char edges[][2], int elen);
	~ListDG();

	// 打印邻接表图
	void print();

private:
	// 读取一个输入字符
	char readChar();
	// 返回ch的位置
	int getPosition(char ch);
	// 将node节点链接到List的最后
	void linkLast(ENode* list, ENode* node);
};

/*
* 创建邻接表对应的图（自己输入）
*/
ListDG::ListDG() {
	char c1, c2;
	int v, e;
	int i, p1, p2;
	ENode* node1, * node2;

	// 输入顶点数和边数
	cout << "input vertex number: ";
	cin >> mVexNum;
	cout << "input edge number: ";
	cin >> mEdgNum;
	if (mVexNum < 1 || mEdgNum < 1 || (mEdgNum > (mVexNum * (mVexNum - 1)))) {
		cout << "input error: invalid parameters! " << endl;
		return;
	}

	// 初始化邻接表的顶点
	for (i = 0; i < mVexNum; ++i) {
		cout << "vertex(" << i << "):";
		mVexs[i].data = readChar();
		mVexs[i].firstEdge = nullptr;
	}

	// 初始化邻接表的边
	for (i = 0; i < mEdgNum; ++i) {
		// 读取边的起始点和结束顶点
		cout << "edge(" << i << "):";
		c1 = readChar();
		c2 = readChar();

		p1 = getPosition(c1);
		p2 = getPosition(c2);
		// 初始化node1
		node1 = new ENode();
		node1->ivex = p2;
		// 将node1链接到p1所在链表的末尾
		if (mVexs[p1].firstEdge == nullptr)
			mVexs[p1].firstEdge = node1;
		else
			linkLast(mVexs[p1].firstEdge, node1);
	}
}

/*
	创建邻接表对应的图（用已经提供的数据）
*/
ListDG::ListDG(char vexs[], int vlen, char edges[][2], int elen) {
	char c1, c2;
	int i, p1, p2;
	ENode* node1, * node2;

	// 初始化顶点数和边数
	mVexNum = vlen;
	mEdgNum = elen;
	// 初始化"邻接表"的顶点
	for (i = 0; i < mVexNum; i++)
	{
		mVexs[i].data = vexs[i];
		mVexs[i].firstEdge = NULL;
	}
	// 初始化邻接表的边
	for (i = 0; i < mEdgNum; ++i) {
		// 读取边的起始顶点和结束顶点
		c1 = edges[i][0];
		c2 = edges[i][1];

		p1 = getPosition(c1);
		p2 = getPosition(c2);
		// 初始化node1
		node1 = new ENode();
		node1->ivex = p2;
		// 将node1链接到p1所在链表的末尾
		if (mVexs[p1].firstEdge == nullptr)
			mVexs[p1].firstEdge = node1;
		else
			linkLast(mVexs[p1].firstEdge, node1);
	}
}

/*
	析构函数
*/
ListDG::~ListDG() {
	
}
/*
	将node节点连接到List最后
*/ 
void ListDG::linkLast(ENode* list, ENode* node) {
	ENode* p = list;

	while (p->nextEdge)
		p = p->nextEdge;
	p->nextEdge = node;
}

/*
	返回ch的位置
*/
int ListDG::getPosition(char ch) {
	int i;
	for (i = 0; i < mVexNum; ++i) 
		if (mVexs[i].data == ch)
			return i;
		return -1; // 失败返回-1
	
}

/*
	读取一个输入字符
*/
char ListDG::readChar() {
	char ch;
	do {
		cin >> ch;
	} while (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')));
	return ch;
}

/*
	打印邻接表图
*/
void ListDG::print() {
	int i, j;
	ENode* node;
	cout << "List Graph: " << endl;
	for (i = 0; i < mVexNum; ++i) {
		cout << i << "(" << mVexs[i].data << "):";
		node = mVexs[i].firstEdge;
		while (node != nullptr) {
			cout << node->ivex << "(" << mVexs[node->ivex].data << ") ";
			node = node->nextEdge;
		}
		cout << endl;
	}
}
int main() {
	char vexs[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
	char edges[][2] = {
		{'A', 'B'},
		{'B', 'C'},
		{'B', 'E'},
		{'B', 'F'},
		{'C', 'E'},
		{'D', 'C'},
		{'E', 'B'},
		{'E', 'D'},
		{'F', 'G'} 
	};
	int vlen = sizeof(vexs) / sizeof(vexs[0]);
	int elen = sizeof(edges) / sizeof(edges[0]);
	ListDG* pG;

	// 自定义图（输入矩阵队列）
	// pG = new ListDG();
	// 采用已经有的图
	pG = new ListDG(vexs, vlen, edges, elen);

	pG->print();
	return 0;
	
}

用已经有的数据运行代码后的结果（有向邻接表图）为：

用自己手动输入数据的结果（有向邻接表图）：

邻接表的实现（无向邻接表图） ：

/*
	C++: 邻接表表示的"无向图(List Undirected Graph)"
	@author lph
	
*/
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;

constexpr auto MAX = 100;
// 邻接表;
class ListUDG {
private:
	// 内部类
	// 邻接表中表对应的链表的顶点
	class ENode {
	public:
		int ivex;		// 该边所指向的顶点的位置
		ENode* nextEdge;// 指向下一条弧的指针
	};
	// 邻接表中表对应的顶点
	class VNode {
	public:
		char data;		// 顶点信息
		ENode* firstEdge;// 指向第一条依赖该顶点的弧
	};
private:
	int mVexNum;		// 图的顶点个数
	int mEdgNum;		// 图的边的数目
	VNode mVexs[MAX];  // 一维数组存储图的顶点，也就是邻接表第一列的顶点
public:
	// 创建邻接表对应的图（自己输入）
	ListUDG();
	// 创建邻接表对应的图（用已经提供的数据）
	ListUDG(char vexs[], int vlen, char edges[][2], int elen);
	// 析构函数
	~ListUDG();
	// 打印邻接表图
	void print();
private:
	// 读取一个输入字符
	char readChar();
	// 返回ch的位置
	int getPosition(char ch);
	// 将node节点链接到list的最后
	void linkLast(ENode* list, ENode* node);
};
/*
	创建邻接表对应的图（自己输入）
*/
ListUDG::ListUDG() {
	char c1, c2;
	// int v, e;
	int i, p1, p2;
	ENode* node1, * node2;
	// 输入顶点数和边数
	cout << "input vertex number: ";
	cin >> mVexNum;
	cout << "input edge number: ";
	cin >> mEdgNum;
	if (mVexNum < 1 || mEdgNum < 1 || (mEdgNum > (mVexNum * (mVexNum - 1)))) {
	cout << "input error: invalid parameters!" << endl;
	return;
}
	// 初始化邻接表的顶点
	for (i = 0; i < mVexNum; ++i) {
		cout << "vertex(" << i << "):";
		mVexs[i].data = readChar(); // 如果mVexs在之前用的是VNode* mVexs[MAX],那么这里需要用指针mVexs[i]->data
		mVexs[i].firstEdge = nullptr;
	}
	// 初始化邻接表的边
	for (i = 0; i < mEdgNum; ++i) {
		// 读取边的起点和结束顶点
		cout << "edge(" << i << "):";
		c1 = readChar();
		c2 = readChar();

		p1 = getPosition(c1);
		p2 = getPosition(c2);
		// 初始化node1
		node1 = new ENode();
		node1->ivex = p2;
		// 将node1链接到p1所在链表的末尾
		if (mVexs[p1].firstEdge == nullptr)
			mVexs[p1].firstEdge = node1;
		else
			linkLast(mVexs[p1].firstEdge, node1);
		// 初始化node2
		node2 = new ENode();
		node2->ivex = p1;
		// 将node2链接到p2所在链表的末尾
		if (mVexs[p2].firstEdge == nullptr)
			mVexs[p2].firstEdge = node2;
		else
			linkLast(mVexs[p2].firstEdge, node2);
	}
}
/*
	创建邻接表对应的图(用已提供的数据)
*/
ListUDG::ListUDG(char vexs[], int vlen, char edges[][2], int elen) {
	char c1, c2;
	int i, p1, p2;
	ENode* node1, * node2;
	// 初始化顶点数和边数
	mVexNum = vlen;
	mEdgNum = elen;
	// 初始化邻接表的顶点
	for (i = 0; i < mVexNum; ++i) {
		mVexs[i].data = vexs[i];
		mVexs[i].firstEdge = nullptr;
	}
	// 初始化邻接表的边
	for (i = 0; i < mEdgNum; ++i) {
		// 读取边的起始顶点和结束顶点
		c1 = edges[i][0];
		c2 = edges[i][1];

		p1 = getPosition(c1);
		p2 = getPosition(c2);
		// 初始化node1
		node1 = new ENode();
		node1->ivex = p2;
		// 将node1链接到p1所在的末尾
		if (mVexs[p1].firstEdge == nullptr)
			mVexs[p1].firstEdge = node1;
		else
			linkLast(mVexs[p1].firstEdge, node1);
		// 初始化node2
		node2 = new ENode();
		node2->ivex = p1;
		// 将node2链接到p2所在链表的末尾
		if (mVexs[p2].firstEdge == nullptr)
			mVexs[p2].firstEdge = node2;
		else
			linkLast(mVexs[p2].firstEdge, node2);
	}
}
/*
	析构函数
*/
ListUDG::~ListUDG() {

}
/*
	将node节点连接到list最后
*/
void ListUDG::linkLast(ENode* list, ENode* node) {
	ENode* p = list;
	while (p->nextEdge)
		p = p->nextEdge;
	p->nextEdge = node;
}
/*
	返回ch的位置
*/
int ListUDG::getPosition(char ch) {
	int i;
	for (i = 0; i < mVexNum; ++i) 
		if (mVexs[i].data == ch)
			return i;
	return -1;
}
/*
	读取一个输入字符
*/
char ListUDG::readChar() {
	char ch;
	do {
		cin >> ch;
	} while  (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')));
	return ch;
}

/*
	打印邻接表图
*/
void ListUDG::print() {
	int i, j;
	ENode* node;
	cout << "List Graph:" << endl;
	for (i = 0; i < mVexNum; ++i) {
		cout << i << "(" << mVexs[i].data << ")";
		node = mVexs[i].firstEdge;
		while (node != nullptr) {
			cout << node->ivex << "(" << mVexs[node->ivex].data << ")";
			node = node->nextEdge;
		}
		cout << endl;
	}
}
int main(){
	char vexs[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
	char edges[][2] = {
		{'A', 'C'},
		{'A', 'D'},
		{'A', 'F'},
		{'B', 'C'},
		{'C', 'D'},
		{'E', 'G'},
		{'F', 'G'} };
	int vlen = sizeof(vexs) / sizeof(vexs[0]);
	int elen = sizeof(edges) / sizeof(edges[0]);
	ListUDG* pG;

	// 自定义"图"(输入矩阵队列)
	//pG = new ListUDG();
	// 采用已有的"图"
	pG = new ListUDG(vexs, vlen, edges, elen);

	pG->print();   // 打印图
	
	return 0;
}

打印已提供邻接表（无向邻接表图）数据的结果： 

 打印自己输入的邻接表（无向邻接表图）的数据：

邻接矩阵的实现请看这里

实现邻接表
及时总结
07-14 453
题目 无向图，共有10个点，输入m条边。 输入： 10 1 2 2 4 3 4 5 6 7 9 10 1 8 9 9 5 3 7 3 8 输出： 1 : 2 10 2 : 1 4 3 : 4 7 8 4 : 2 3 5 : 6 9 6 : 5 7 : 9 3 8 : 9 3 9 : 7 8 5 10 : 1 代码： #include <iostream> #include<vec...
c语言邻接表,C++数据结构之实现邻接表
weixin_42405890的博客
05-23 1196
本文实例为大家分享了C++数据结构之实现邻接表的具体代码，供大家参考，具体内容如下一、图的邻接表实现1.实现了以顶点顺序表、边链表为存储结构的邻接表；2.实现了图的创建(有向/无向/图/网)、边的增删操作、深度优先递归/非递归遍历、广度优先遍历的算法；3.采用顶点对象列表、边(弧)对象列表的方式，对图的创建进行初始化；引用 "ObjArrayList.h"头文件，头文件可参看之前博文“数据结构之顺...
【数据结构与算法】图的概念 && 邻接矩阵实现 && 邻接表实现 && DFS && BFS
lirendada的博客
02-18 1068
​邻接矩阵和邻接表是相辅相成的，各有优缺点，要根据实际情况进行选择，有时候也可以一起使用他们进行搭配！​ 一般情况下，对于稠密图，我们选择邻接矩阵；对于稀疏图，我们选择邻接表！​ 下面我们讲解各种算法的时候，采用的是邻接矩阵来实现，因为一般我们在做oj以及实现一些算法的时候，邻接矩阵会用的比较多~
邻接表（C++）
ddez46767的博客
02-22 412
adj_list_network_edge.h 1 // 邻接表网边数据类模板 2 template <class WeightType> 3 class AdjListNetworkEdge 4 { 5 public: 6 // 数据成员: 7 int adjVex; //...
C++语言实现-邻接表
weixin_30815427的博客
11-14 439
图的邻接表实现 邻接表是图的一种链式存储结构。主要是应对于邻接矩阵在顶点多边少的时候，浪费空间的问题。它的方法就是声明两个结构。如下图所示： 先来看看伪代码： typedefcharVertextype; //表结点结构 structArcNode { intadjvex; //某条边指向的那个顶点的位置（一般是数组的下标）。 ArcNod...
C++实现的邻接表
二哈
06-17 9636
1. 在学习图的存储方式中，邻接矩阵和邻接表是两种比较常用的存储图的方式，下面使用的是C语言实现的邻接表 2. 具体的实现过程如下： ① 首先使用结构体声明图的结构体，图中顶点的结构体，以及指向下一条边的结构体，这些可以参照严蔚敏版的数据结构来写出具体的数据结构： typedef struct ArcNode{ int adjvex;//该边所指向的节点的位置 struct ArcN...
c++实现邻接表（附带源码）
欢迎来到我的博客！这里是一个专注于计算机技术的分享平台，涵盖编程开发、算法研究、系统架构、软件工程等多个领域。无论你是初学者还是资深开发者，都能在这里找到有价值的内容。
01-24 503
在图论中，邻接表（Adjacency List）是一种常见的图表示方式，用于存储图的结构。邻接表由一个数组（或哈希表）组成，数组中的每个元素对应图中的一个顶点，每个顶点保存一个链表或其他容器，该链表存储与该顶点直接相连的所有邻接顶点。邻接表适用于稀疏图，因为它能够有效地减少存储空间。
C++实现有向图的邻接表表示
12-20
【有向图与邻接表】 有向图是一种图结构，其中的边具有方向性，即每条边都有明确的起点（头）和终点（尾）。与无向图不同，有向图的边不一定是双向的。在邻接表表示法中，有向图的每个顶点都有一个链表，链表中的每...
C++实现有向图邻接表的构建
08-19
C++实现有向图邻接表的构建 本文主要介绍了C++实现有向图邻接表的构建，通过示例代码详细介绍了有向图邻接表的构建过程。下面是对标题、描述、标签和部分内容的详细解释： 一、有向图邻接表的概念 有向图邻接表是...
C++_使用邻接表(链表-指针)实现有向图[完整示例及解释]
book_dw5189的博客
05-05 1382
// newNode->next = nodes[sourceIndex].head;将新节点 newNode 的 next 指针指向了源节点的邻接表的头部。这样，新节点就被插入到了邻接表的头部位置。
邻接表的实现
weixin_34050389的博客
09-30 158
今天想练习一下图算法，有些图算法的基础数据结构是邻接表，于是想着用C实现一下，虽说wiki上有一个邻接表的实现，但是自己还是想练一下手，在网上也搜到了别人的邻接表实现，发现大同小 异，然后就在别人的基础上修改了一下得到了这个版本，记录一下，供以后练习使用。 1.邻接表概念 一张图，如果不考虑空间占用问题的话，用邻接矩阵存储是最方便的了，但有时候，图很稀疏，用矩阵存储就不划算了...
邻接表c++版
scorpion_legend的博客
10-30 491
//邻接表 #include<bits/stdc++.h> using namespace std; #define MAXNODE 100//最大顶点数 typedef char VertexType;//顶点类型 typedef int EdgeTypd;//边权数据类型 typedef struct EdgeNOde//边表节点 { int node_index; EdgeTypd weight; struct EdgeNOde* next; }EdgeNOde;
邻接表详解（C/C++）
热门推荐
莫浅子的博客
08-24 4万+
一、概念 二、分类 1）无向图的邻接表 2）有向图的邻接表（出弧） 3）有向图的逆邻接表（入弧） 三.步骤 四、代码
数据结构邻接表c++
qq_63881564的博客
08-13 433
个人学习所记笔记，如有错误，请见谅
c++邻接表
123456
07-17 325
114514
c++数据结构：图（邻接表）
qq_45303986的博客
10-19 2936
想更容易的找到入度的话，可以构建逆邻接表：（指向反转）邻接表是图的一种链式结构。
c++实现邻接表
orange_monkey的博客
11-26 2191
#include<iostream> using namespace std; const int MAX = 10; //声明边表结点 struct edge_node { int adjvex; //邻接点域,储存该顶点对应的下标 int weight; //权值 edge_node *next; //指向边表下一个结点 }; //声明顶点表结点 struct vertex_node { char vertex; //顶点 edge_node *first_edge; //指
邻接链表C++
最新发布
04-03
### C++ 中实现邻接链表的数据结构 以下是基于引用内容以及专业知识构建的一个完整的邻接链表实现方案。该示例展示了如何使用 C++ 创建图的邻接链表表示法，支持添加顶点、边的操作，并能够打印整个邻接列表。 #### 1. 定义节点和图的基本结构 为了实现邻接链表，我们需要定义两个主要类：`Node` 和 `Graph`。 - `Node` 表示图中的每一个顶点及其相邻顶点的信息。 - `Graph` 是管理这些顶点的核心容器。 ```cpp #include <iostream> #include <list> using namespace std; class Graph { int V; // 图中顶点的数量 list<int> *adj; // 指向邻接链表数组的指针 public: // 构造函数 Graph(int V) { this->V = V; adj = new list<int>[V]; } // 添加一条无向边到图中 void addEdge(int v, int w) { adj[v].push_back(w); // 将 w 加入到 v 的邻接链表中 adj[w].push_back(v); // 如果是无向图，则也需要将 v 加入到 w 的邻接链表中 } // 打印邻接链表的内容 void printGraph() { for (int i = 0; i < V; ++i) { cout << "Vertex " << i << ": "; for (auto it : adj[i]) { cout << "-> " << it; } cout << endl; } } }; ``` 上述代码实现了基本的图结构初始化方法[^3]，并提供了用于添加边的功能。通过动态分配内存给邻接链表数组，我们可以在运行时灵活调整图的大小。 #### 2. 使用示例 下面是一个简单的测试程序，展示如何创建一个具有四个顶点的小型图，并为其添加几条边： ```cpp int main() { int V = 4; // 假设图有 4 个顶点 Graph g(V); // 向图中添加一些边 g.addEdge(0, 1); g.addEdge(0, 2); g.addEdge(1, 2); g.addEdge(2, 3); // 输出最终形成的邻接链表 g.printGraph(); return 0; } ``` 执行此代码后，输出将是这样的形式： ``` Vertex 0: -> 1-> 2 Vertex 1: -> 0-> 2 Vertex 2: -> 0-> 1-> 3 Vertex 3: -> 2 ``` 这表明每个顶点与其邻居之间的连接关系已经成功建立。 #### 关键概念解析 - **邻接链表**：这是一种高效存储稀疏图的方式，在空间复杂度上优于矩阵表示法。 - **动态内存分配**：由于实际应用中的图规模可能变化很大，因此采用动态分配技术是非常必要的。 - **STL 列表**：标准模板库 (`std::list`) 提供了一个双向链表实现，非常适合用来模拟邻接链表的行为特性。 --- ###
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值