数据结构——图（Graph）

社恐不参团的Traibin

于 2024-05-07 18:34:55 发布

阅读量788

点赞数 15

分类专栏：数据结构文章标签：数据结构

本文链接：https://blog.csdn.net/traibin/article/details/138357433

版权

数据结构专栏收录该内容

1 篇文章 0 订阅

订阅专栏

图的概念

概括

图都由顶点（Vertex）和边（Edge）有限集合而成
图分为无向图和有向图
无向图：代表边的顶点对（或序偶）是无序的，则称为无向图。代表边的无序顶点对通常用圆括号括起来，以表示一条无向边。（i，j）
有向图：表示边的顶点对（或序偶）是有序的，则称为有向图。代表边的无序顶点对通常用尖括号括起来，以表示一条有向边。<i，j>

图1：无向图和有向图的示意图

基本术语

1、端点和邻接点
在一个无向图中,若存在一条边(i，j),则称顶点“i”和顶点“j“为该边的两个端点，并称它们互为邻接点，即顶点”i“是顶点”j“的一个邻接点，顶点j也是顶点i的一个邻接点。
在一个有向图中，若存在一条边<i,j>，则称此边是顶点”i“的一条出边,同时也是顶点”j“的一条入边；称”i“和”j“分别为此边的起始端点(简称为起点)和终止端点(简称为终点)，并称顶点”j“是”i“的出边邻点，顶点”i“是”j“的入边邻接点。
2、顶点的度、入度和出度
在无向图中，顶点所关联的边的数目称为该顶点的度。在有向图中，顶点”i“的度又分为入度和出度，以顶点”i“为终点的入边的数目称为该顶点的入度，以顶点”i“为起点的出边的数目称为该顶点的出度。一个顶点的入度与出度的和为该顶点的度。一个图中所有顶点的度之和等于边数的两倍。因为图中的每条边分别作为两个邻接点的度各计一次。
3、完全图
若无向图中的每两个顶点之间都存在一条边 ,有向图中的每两个顶点之间都存在方向相反的两条边，则称此图为完全图。显然,含有n个顶点的完全无向图有n(n-1)/2条边，含有n个顶点的完全有向图有n(n-1)条边。
4、连通、连通图和连通分量
在无向图G中,若从顶点”i“到顶点”j”有路径,则称顶点“i”和顶点“j”是连通的。若图G中的任意两个顶点都连通，则称G为连通图，否则称为非连通图。无向图G中的极大连通子图称为G的连通分量。显然，任何连通图的连通分量只有一个，即它本身，而非连通图有多个连通分量。
4、强连通图和强连通分量
在有向图G中,若从顶点“i”到顶点“j”有路径，则称从顶点“i”到顶点“j”连通的。若图G中的任意两个顶点“i”和“j”都连通，即从顶点“i”到顶点“j”和从顶点“j”到顶点“i’都存在路径，则称图G是强连通图。有向图G中的极大强连通子图称为G的强连通分量。显然,强连通图只有一个强连通分量，即它本身，非强连通图有多个强连通分量。一般地，单个顶点自身就是一个强连通分量。
5、权和网
图中的每一条边都可以附有一个对应的数值。这种与边相关的数值称为权。权可以表示从图中顶点到另一个顶点的距商或花费的代价。边上带有权的图称为带权图。也称作网。

图的存储结构

邻接矩阵

邻接矩阵是表示顶点之间邻接关系的矩阵。设G=(V ,E)是含有n(设n>0)个顶占的图,各顶点的编号为0~n-1,则G的邻接矩阵数组A是n阶方阵,其定义如下
如果G是不带权图(或无权图),则:

如果G是带权图(或有权图)，则:

图2：2个邻接矩阵

邻接矩阵的基本结构运行算法代码

const int MAXV=100;        //图中最多的顶点数
const int INF=0x3f3f3f3f;    //用INF表示∞
class MaxGraph
{
public:
    int edges[MAXV][MAXV];    //邻接矩阵数组，假设元素为int
    int n,e;                    //顶点数和边数
    string vexs[MAXV];        //存放顶点信息
};

图的邻接矩阵存储结构的特点如下:
1、图的邻接矩阵表示是唯一的。
2、对于含有n个顶点的图，在采用邻接矩阵存储时，无论是有向图还是无向图，也无论边的数目是多少,其存储空间均为O（n^2）所以邻接矩阵适合干存储边数较多的调密图
3、无向图的邻接矩阵一定是对称矩阵，因此在顶点个数n很大时可以采用对称矩阵的压缩存储方法减少存储空间。有向图的邻接矩阵不一定是对称矩阵。
4、对于无向图，邻接矩阵的第i行(或第i列)非零/非∞元素的个数正好是顶点i的度；对于有向图，邻接矩阵的第i行(或第i列)非零/非∞元素的个数正好是顶点i的出度(或入度)
5、用邻接矩阵存储图时，确定任意两个顶点之间是否有边相连的时间为0(1）

邻接矩阵代码实现

创建邻接矩阵

void CreateMatGraph(int a[][MAXV],int n,int e)
{
    this->n=n;
    this->e=e;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
              this->edges[i][j]=a[i][j];
        }
     }
}

输出图

void DispMatGraph()
{
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            if(edge[i][j]==INF)
                 printf("%4s","∞");
            else
                 printf("%4d",edges[i][j]);     
           printf("\n");
         }
     }
}

邻接表

在含n个顶点的图G的邻接表中，顶点i（0≤i≤n-1）的每一条出边<i，j>（权值为W）对应一个边结点，顶点i的所有出边的边结点构成一个单链表，其中边结点的类型ArcNode
定义如下

struct ArcNode        //边结点类型
{
    int adjvex;        //邻接点
    int weight;        //权值
    ArcNode* nextarc； //指向下一边的边结点
};

给顶点i的单链表加上一个头结点，包含顶点i的信息和指向第一条边的边结点的指针，头结点的类型如下

struct HNode            //头结点类型
{
    string info;        //顶点信息
    ArcNode* firstarc;  //指向第一条边的边结点
};

图3：有向图的邻接表和有向图包含权值的邻接表

设计图的邻接表类AdjGraph如下

template<class i>
class AdjGraph		//图邻接表类
{
public:
	HNode adjlist[MAXV];	//头结点数组
	int n, e;
	AdjGraph()
	{
		for (int i = 0; i < MAXV; i++)
		{
			adjlist[i].firstarc = NULL;
		}
	}
	~AdjGraph()
	{
		ArcNode* pre, * p;
		for (int i = 0; i < n; i++)		//遍历所有头结点
		{
			pre = adjlist[i].firstarc;	//用一个ArcNode指针指向头结点的fitst区域
			if (pre != NULL)			//若不为空
			{
				p = pre->nextarc;		//则用另外一个ArcNode指针指向头结点的下一个结点
				while (p != NULL)		//释放过程，循环删除
				{
					delete pre;			
					pre = p; p = p->nextarc;	//两个指针同步后移
				}
				delete pre;
			}
		}
	}
	void CreateAdjGraph(int a[][MAXV], int n, int e);	//通过a，n，e来建立图的邻接表	
	void DispAdjGraph();								//输出图的邻接表
	int Degree1(AdjGraph* G, int v);					//计算无向图某个顶点的度，v为顶点名称
	i Degree2(AdjGraph& G, int v);				//计算有向图某个顶点的出度和入度，v为顶点名称
};

图的基本运算在邻接表中的实现

假设给定邻接矩阵数组啊，顶点数n和边数e来建立图的。

邻接表存储结构

template<typename i>
void AdjGraph<i>::CreateAdjGraph(int a[][MAXV], int n, int e)
{
	ArcNode* p;
	this->n = n; this->e = e;
	for (int i = 0; i < n; i++)
	{
		for (int j = n - 1; j >= 0; j--)
		{
			if (a[i][j] != 0 && a[i][j] != INF)
			{
				p = new ArcNode;					//指针类型的构造函数
				p->adjvex = j;
				p->weight = a[i][j];
				p->nextarc = adjlist[i].firstarc;	//采用头插法插入p
				adjlist[i].firstarc = p;

			}
		}
	}
}

输出图邻接表

template<typename i>
void AdjGraph<i>::DispAdjGraph()
{
	ArcNode* p;
	for (int i = 0; i < n; i++)						//遍历每一个头结点
	{
		printf(" [%d]", i);
		p = adjlist[i].firstarc;					//p指向第一个邻接点
		if (p != NULL)
			printf("->");
		while (p!= NULL)
		{
			printf("(%d,%d)", p->adjvex, p->weight);
			p = p->nextarc;							//p移向下一个邻接点
		}
		printf("\n");
	}
}

邻接表计算无向图某个顶点的度

template<typename i>
int AdjGraph<i>::Degree1(AdjGraph* G, int v)			//主要是用来统计某个顶点v的边数的算法
{
	int d = 0;
	ArcNode* p = G->adjlist[v].firstarc;
	while (p != NULL)								//对顶点v中的边数进行统计
	{
		d++;
		p = p->nextarc;
	}
	return d;
}

邻接表计算有向图某个顶点的出度和入度

template<typename i>
i AdjGraph<i>::Degree2(AdjGraph& G, int v)
{
	i ans = { 0,0 };						//ans[o]累计出度，ans[i]累计入读
	ArcNode* p = G.adjlist[v].firstarc;
	while (p != NULL)						//统计单链表v中顶点边结点个数
	{
		ans[0]++;
		p = p->nextarc;
	}
	for (int i = 0; i < G.n; i++)			//统计所有adjvex为v的边结点个数即为顶点v的入读
	{
		p = G.adjlist[i].firstarc;
		while (p != NULL)
		{
			if (p->adjvex == v)
			{
				ans[1]++;
				break;						//在一个单链表中最多只有一个这样的结点
			}
			p = p->nextarc;
		}
	}
	return ans;								//返回出度和入读
}

图的遍历

从给定图中任意指定的顶点（称为初始点）出发，按照某种搜索方法沿着图的边访问图中的所有顶点，使每个顶点访问一次且仅访问一次，这个过程称为图的遍历。图的遍历得到的顶点序列称为图遍历序列。

抽象操作，可以是对结点进行的各种处理，这里简化为输出结点的数据信息。
为了保证图中的各顶点在遍历过程中访问到且仅访问一次，需要为每个顶点设一个访问标志；
可以为图设置一个访问标志数组visited［n］，用于标示图中每个顶点是否被访问过，它的所有数组元素初始值为0，表示顶点均未被访问，一旦访问过顶点vi，则置访问标志数组中的visited［i］为1，以表示该顶点已访问。

深度优先遍历

思想（先深搜索）：
1、深度优先遍历是指在图中任选一个顶点V，访问V并以V作为初始点；
2、选择一个与顶点V相邻且未曾访问过的顶点W，访问W，并以W作为新的出发点，继续进行深度优先遍历；
3、若访问到某个顶点时，发现该顶点的所有邻接点均已访问过，则回溯到前一个访问过的顶点，从该顶点出发继续进行深度优先遍历。直到一直回溯到出发顶点V，并且图中与顶点V邻接的所有顶点均被访问过。
4、若此时图中任有未访问的顶点（说明是非连通图），则另选一个尚未访问的顶点作为新的出发点，重复上述过程，直到图中所有顶点均已被访问为止。

基本定义的结构体和类如下

#include<iostream>
#include<string>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXV = 1000;
struct ArcNode
{
	int adjvex;		//邻接点
	int weight;		//权值
	ArcNode* nextarc;	//指向下一条边的边结点
};
struct HNode
{
	string info;	//顶点信息
	ArcNode* firstarc;	//指向第一条边的边结点
};

class AdjGraph		//图邻接表类
{
public:
	HNode adjlist[MAXV];	//头结点数组
	int n, e;
	AdjGraph()
	{
		for (int i = 0; i < MAXV; i++)
		{
			adjlist[i].firstarc = NULL;
		}
	}
	~AdjGraph()
	{
		ArcNode* pre, * p;
		for (int i = 0; i < n; i++)		//遍历所有头结点
		{
			pre = adjlist[i].firstarc;	//用一个ArcNode指针指向头结点的fitst区域
			if (pre != NULL)			//若不为空
			{
				p = pre->nextarc;		//则用另外一个ArcNode指针指向头结点的下一个结点
				while (p != NULL)		//释放过程，循环删除
				{
					delete pre;
					pre = p; p = p->nextarc;	//两个指针同步后移
				}
				delete pre;
			}
		}
	}
	void DFS(AdjGraph& G, int v);		//深度优先遍历（邻接表）
    void BFS(AdjGraph& G, int v);		//广度优先遍历（邻接表）
};