图的存储结构C++实现

关注

原创最新推荐文章于 2026-03-30 07:59:33 发布 1.9k 阅读 AI 写同款· GEO 优化 ›

C++简单的图存储第一次写博客，格式什么的就不太拘谨，以后会慢慢调整。本文解决的问题： 1.如何在C++中进行图的存储，以及对图进行一些简单操作废话不多说，直接上干货。我的图存储主要有3个类：Graph 图类 Vertex 点类 Edge 边类其中点在图中用数组的形式存储（因为一般情况下，简单的图点数一般不会太多，这里设置一个maxnum = 100常量足够解决一般图的存储问题），边在点类中用vec 阅读详情

图结构作为一种比线性表和树更为复杂的数据结构，任意两个数据元素之间都有可能相关。在离散数学中有图论一章，就是专门研究图的性质的。

数据的逻辑结构是非线性的图结构，一个节点可能有多个前驱、多个后继；

从存储结构上来说，只有链式存储结构，没有顺序存储结构。但是，可以通过一个邻接矩阵表示两结点之间的连接关系。

图的具体分为：无向图、有向图、无向网、有向网

邻接矩阵表示法

#pragma once
#include<iostream>
using namespace std;

const int MaxInt = 32767;
const int MVNum = 10;
typedef char Elemtype;

typedef enum { DG, DN, UDG, UDN } GraphKind;//创建一个枚举类型GraphKind
//DG:有向图      DN:有向网      UDG：无向图       UDN：无向网


class AMGraph
{

public:
	AMGraph(GraphKind k);
	void Create();//创建网or图
	int LocateVex(const Elemtype s);//定位邻接矩阵中的1或者权值的位置
	void Printarcs();//打印邻接矩阵


private:
	GraphKind kind;
	Elemtype vexs[MVNum];//创建一个顶点表
	int arcs[MVNum][MVNum];//邻接矩阵
	int vex_num;//当前的顶点数
	int arc_num;//当前的边数

};

AMGraph::AMGraph(GraphKind k)
{ 
	this->kind = k; 
	this->vex_num = 0;
	this->arc_num = 0;
}


void AMGraph::Create()
{
	cout << "输入总顶点数："; cin >> this->vex_num;
	cout << "输入总边数："; cin >> this->arc_num;
	cout << "初始化顶点表！" << endl;  //也就是说输入点的信息
	//初始化一下这个矩阵
	for (int i = 0; i < this->vex_num; i++)
	{
		cout << "请输入第" << i + 1 << "个点的信息:";
		cin >> vexs[i];
	}
	for (int i = 0; i < this->vex_num; i++)
	{
		for (int j = 0; j < this->vex_num; j++)
		{
			if (this->kind == 0 || this->kind == 2)
				this->arcs[i][j] = 0;
			else
				this->arcs[i][j] = MaxInt;
		}
	}
	//正式构建邻接矩阵
	for (int i = 0; i < this->arc_num; i++)
	{
		Elemtype s1, s2;
		int val=1;
		int locate1=-1, locate2=-1;
		cout << "输入第一个点：" << endl; cin >> s1;
		cout << "输入第二个点：" << endl; cin >> s2;
		if (this->kind == 1 || this->kind == 3)
		{
			cout << "输入权值："; cin >> val;
		}
		locate1 = this->LocateVex(s1);
		locate2 = this->LocateVex(s2);
		if (locate1 == -1 || locate2 == -1)
			return;
		switch (this->kind)
		{
		case  DG:
			this->arcs[locate1][locate2] = 1;
			break;
		case DN:
			this->arcs[locate1][locate2] = val;
			break;
		case UDG:
			this->arcs[locate1][locate2] = 1;
			this->arcs[locate2][locate1] = 1;
			break;
		case UDN:
			this->arcs[locate1][locate2] = val;
			this->arcs[locate2][locate1] = val;
			break;
		default:
			break;
		}
	}
}



int AMGraph::LocateVex(const Elemtype s)
{
	/*cout << typeid(this->vexs[0]).name() << endl;
	cout << typeid(s).name() << endl;*/
	for (int i = 0; i < this->vex_num; i++)
	{
		if (s == this->vexs[i])
			return i;//如果找到喽 就返回在顶点表中的下标
	}
	return -1;//如果没找到，就返回-1
}

void AMGraph::Printarcs()
{
	for (int i = 0; i < this->vex_num; i++)
	{
		for (int j = 0; j < this->vex_num; j++)
		{
			cout << this->arcs[i][j] << "\t";
		}
		cout << endl;
	}
}

邻接表表示法

图中的每一个顶点建立一个单链表，把与结点相邻接的顶点放在链表中，顶点（表头节点）组成一个线性表，表头结点的指针域指向边表，时间复杂度O(n+e)(e:边数)

查看源图像

关于邻接表表示法的相关理论可参考诸多数据结构与算法书籍，下面给出邻接表的表示方法：

#pragma once
#include<iostream>
using namespace std;

typedef char Elemtype;
const int MaxInt = 32767;

typedef enum { DG, DN, UDG, UDN } GraphKind;//创建一个枚举类型GraphKind
//DG:有向图      DN:有向网      UDG：无向图       UDN：无向网

//可以通过邻接表实现四种kind的计算机存储结构
//邻接表的三部分定义：边结点、存放顶点的头结点线性表、图的类型

class ArcNode//定义了边结点
{
public:
	int adjvex;//邻接顶点所在表中下标
	int weight;//边权重
	ArcNode* nextarc;//指向下一条边的指针
};
class VNode
{
public:
	Elemtype data;
	ArcNode* firstarc;
};
class ALGraph
{
public:
	ALGraph(GraphKind k);
	void CreateALG();//创建邻接表
	int LocateVex(const Elemtype s);
private:
	VNode* vertices;
	GraphKind kind;
	int vex_num;
	int arc_num;
};

ALGraph::ALGraph(GraphKind k)
{
	this->vex_num = 0;
	this->arc_num = 0;
	this->kind = k;
	this->vertices = nullptr;
}


void ALGraph::CreateALG()
{
	cout << "输入总顶点数："; cin >> this->vex_num;
	cout << "输入总边数："; cin >> this->arc_num;
	//初始化顶点表
	this->vertices = new VNode[vex_num];
	for (int i = 0; i < this->vex_num; i++)
	{
		cout << "输入顶点表中的数据域："; cin >> vertices[i].data;
		vertices[i].firstarc = nullptr;
	}
	//边结点的链接
	for (int i = 0; i < this->arc_num; i++)
	{
		Elemtype s1, s2;
		int locate1 = -1, locate2 = -1;
		cout << "输入第1点：" << endl; cin >> s1;
		cout << "输入第2点：" << endl; cin >> s2;
		locate1 = this->LocateVex(s1);
		locate2 = this->LocateVex(s2);
		int val=1;
		if (this->kind == 1 || this->kind == 3)//如果创建的是有向网\无向网就输入对应的权值
		{
			cout << "输入权值："; cin >> val;
		}
		ArcNode* p;
		p = new ArcNode;
		p->weight = val;
		p->adjvex = locate2;
		p->nextarc = this->vertices[locate1].firstarc;
		this->vertices[locate1].firstarc = p;
		if (this->kind == 2 || this->kind == 3)//如果无向图/无向网
		{
			ArcNode* p1;
			p1 = new ArcNode;
			p1->weight = val;
			p1->adjvex = locate1;
			p1->nextarc = this->vertices[locate2].firstarc;
			this->vertices[locate2].firstarc = p1;
		}
	}
}

int ALGraph::LocateVex(const Elemtype s)
{
	for (int i = 0; i < this->vex_num; i++)
	{
		if (s == this->vertices[i].data)
			return i;//如果找到喽 就返回在顶点表中的下标
	}
	return -1;//如果没找到，就返回-1
}

邻接表缺点：对于图来说，需要开辟两个空间来记录两个结点之间的关系，这对于后续的删除以及图的遍历都是不利的，为了克服这一缺点，引入邻接多重表；

对于有向图/网来说，一个结点只能记录他的出度，却不能记录入度，因此引入了十字链表，求得顶点的入度和出度.

图的遍历(邻接表的实现)

下面的两段程序是针对邻接表进行的深度优先搜索（DFS）和广度优先搜索（BFS），下面的程序是邻接表程序上又加了几个成员函数

以邻接表为表示方法，深度优先算法，更像是看到一个结点，一看他没被访问过，就立马就再从表结点出发，以该结点为出度边，递归访问，这样来回得穿梭于表头结点和边结点之间，从图形上是说是“一条道走到黑”；

而广度优先算法，更像是从邻接表上起始点出发，一条道走到黑，路上把所有遍历的且之前未访问过的结点，放到容器中，走到黑之后，再掉头从queue中输出队列元素，继续再邻接表上一条道走到黑，不用递归噢，走到黑之后，让容器再给你吐出来一个起始点。

类.hpp

#pragma once
#pragma once
#include<iostream>
#include<queue>
using namespace std;

typedef char Elemtype;
const int MaxInt = 32767;

typedef enum { DG, DN, UDG, UDN } GraphKind;//创建一个枚举类型GraphKind
//DG:有向图      DN:有向网      UDG：无向图       UDN：无向网

//可以通过邻接表实现四种kind的计算机存储结构
//邻接表的三部分定义：边结点、存放顶点的头结点线性表、图的类型

class ArcNode//定义了边结点
{
public:
	int adjvex;//邻接顶点所在表中下标
	int weight;//边权重
	ArcNode* nextarc;//指向下一条边的指针
};
class VNode
{
public:
	Elemtype data;
	ArcNode* firstarc;
};
class ALGraph
{
public:
	ALGraph(GraphKind k);
	void CreateALG();//创建邻接表
	void InitArry();//标志数组置空
	void DFS_AL(const Elemtype s);//输入时图中的某一个结点，深度优先遍历，采用邻接表表示,本质上操作对象还是表头结点表，而非依靠边结点输出
	void BFS_AL(const Elemtype s);//广度优先访问连通图，还有构建一个标志数组
private:
	int LocateVex(const Elemtype s);//根据输入的s值，确定要连接的两个点在表头结点中的位置


	VNode* vertices;
	GraphKind kind;
	int vex_num;
	int arc_num;
	int* visitedDFS;
	queue<int> Q;
};

ALGraph::ALGraph(GraphKind k)
{
	this->vex_num = 0;
	this->arc_num = 0;
	this->kind = k;
	this->vertices = nullptr;

}


void ALGraph::CreateALG()
{
	//初始化顶点表
	cout << "输入总顶点数："; cin >> this->vex_num;
	cout << "输入总边数："; cin >> this->arc_num;
	//初始化标志数组
	this->visitedDFS = new int[vex_num];
	for (int j = 0; j < this->vex_num; j++)
	{
		visitedDFS[j] = 0;//默认都没有访问过
	}
	//初始化表头
	this->vertices = new VNode[vex_num];
	for (int i = 0; i < this->vex_num; i++)
	{
		cout << "输入顶点表中的数据域："; cin >> vertices[i].data;
		vertices[i].firstarc = nullptr;
	}
	//边结点的链接
	for (int i = 0; i < this->arc_num; i++)
	{
		Elemtype s1, s2;
		int locate1 = -1, locate2 = -1;
		cout << "输入第1点：" ; cin >> s1;
		cout << "输入第2点：" ; cin >> s2;
		locate1 = this->LocateVex(s1);
		locate2 = this->LocateVex(s2);
		int val = 1;
		if (this->kind == 1 || this->kind == 3)//如果创建的是有向网\无向网就输入对应的权值
		{
			cout << "输入权值："; cin >> val;
		}
		ArcNode* p;
		p = new ArcNode;
		p->weight = val;//头插法
		p->adjvex = locate2;
		p->nextarc = this->vertices[locate1].firstarc;
		this->vertices[locate1].firstarc = p;
		if (this->kind == 2 || this->kind == 3)//如果无向图/无向网
		{
			ArcNode* p1;
			p1 = new ArcNode;
			p1->weight = val;
			p1->adjvex = locate1;
			p1->nextarc = this->vertices[locate2].firstarc;
			this->vertices[locate2].firstarc = p1;
		}
	}
}

int ALGraph::LocateVex(const Elemtype s)
{
	for (int i = 0; i < this->vex_num; i++)
	{
		if (s == this->vertices[i].data)
			return i;//如果找到喽 就返回在顶点表中的下标
	}
	return -1;//如果没找到，就返回-1
}

void ALGraph::InitArry()//为了防止一次程序中反复遍历图，所以提供给标志数组置0，这样的话，进行多次遍历的时候主程序都将其置空一次；
{
	for (int i = 0; i < this->vex_num; i++)
	{
		this->visitedDFS[i] = 0;
	}
}

void ALGraph::DFS_AL(const Elemtype s)
{//邻接表的展现方式
	cout << s << "\t";//麻溜把结点输出来;
	int locate = this->LocateVex(s);
	this->visitedDFS[locate] = 1;
	ArcNode* p;
	p = this->vertices[locate].firstarc;
	while (p)
	{
		int index = p->adjvex;//获得点的索引下标
		if (!this->visitedDFS[index])
			this->DFS_AL(this->vertices[p->adjvex].data);
		p = p->nextarc;
	}
}

void ALGraph::BFS_AL(const Elemtype s)//不需要遍历，但需要一个队列容器
{
	cout << s << "\t";
	int index = this->LocateVex(s);
	this->visitedDFS[index] = 1;
	this->Q.push(index);
	while (!Q.empty())
	{
		int num = Q.front();
		Q.pop();
		ArcNode* p;
		p = this->vertices[num].firstarc;
		while (p)
		{
			if (this->visitedDFS[p->adjvex] == 0)
			{
				cout << this->vertices[p->adjvex].data << "\t";
				this->visitedDFS[p->adjvex] = 1;
				Q.push(p->adjvex);
			}
			p = p->nextarc;//如果被访问过了，还要继续去顺着边结点寻找噢，所以这个程序不能放在if语句中
		}
	}
	cout << endl;
}

主程序.cpp

#include <iostream>
#include"图邻接表实现.hpp"
using namespace std;

int main()
{ 
	ALGraph K(UDG);
	K.CreateALG();
	K.DFS_AL('A');
	cout << endl;
	K.InitArry();
	K.BFS_AL('A');

	system("pause");
	return 0;
}

结果：答案不唯一，由于子图在遍历的时候没有顺序，所以先访问A之后访问B或C都行

原型：