图
1.什么是图？
图是一种复杂的非线性结构。
在线性结构中，数据元素之间满足唯一的线性关系，每个数据元素(除第一个和最后一个外)只有一个直接前趋和一个直接后继；
在树形结构中，数据元素之间有着明显的层次关系，并且每个数据元素只与上一层中的一个元素(双亲节点)及下一层的多个元素(孩子节点)相关；
而在图形结构中，节点之间的关系是任意的，图中任意两个数据元素之间都有可能相关。
图G由两个集合V(顶点Vertex)和E(边Edge)组成，定义为G=(V，E)
2.图的相关概念
2.1有向图与无向图
对于一个图，若每条边都是没有方向的，则称该图为无向图。
对于一个图，若每条边都是有方向的，则称该图为有向图。
2.1.1无向图：
因此，(0，2)和(2，0)表示的是同一条边。注意，无向图是用小括号，有向图是用尖括号。
无向图的顶点集和边集分别表示为：
V(G)={0，1, 2，3}
E(G)={(0，1)，(0，2)，(0，3)，(1，2)，(1，3)，(2，3)}
2.1.2有向图：
有向图的顶点集和边集分别表示为：
V(G)={0，1，2，3}
E(G)={<0，1>，<0，2>，<0，3>，<1，0>，<1，2>，<1，3>,<2，0>，<2，1>，<2，3>,<3，0>，<3，1>，<3，2>}
2.2度
顶点v的度是指与它相关联的边的条数，记作deg(v)。
在有向图中，顶点的度等于该顶点的入度与出度之和，其中顶点v的入度是以v为终点的有向边的条数，记作indev(v);顶点v的出度是以v为起始点的有向边的条数，记作outdev(v)。
因此：dev(v) = indev(v) + outdev(v)
对于无向图，顶点的度等于该顶点的入度和出度，即dev(v) = indev(v) = outdev(v)
2.3连通图与强连通图
连通图：在无向图中，若从顶点v1到顶点v2有路径，则称顶点v1与顶点v2是连通的。如果图中任意一对顶点都是连通的，则称此图为连通图。
强连通图：在有向图中，若在每一对顶点vi和vj之间都存在一条从vi到vj的路径，也存在一条从vj到vi的路径，则称此图是强连通图。
2.4完全图
完全图：
在有n个顶点的无向图中，若有n*(n-1)/2条边，即任意两个顶点之间有且仅有一条边，则称此图为无向完全图；
在n个顶点的有向图中，若有n*(n-1)条边，即任意两个顶点之间有且仅有方向相反的边，则称此图为有向完全图。
2.5网
带”权值”的连通图称为网。
3.图的存储
图的存储分为两种，邻接表和邻接矩阵。
3.1邻接表
邻接表：邻接表是图的一种链式存储结构。这种存储结构类似于树的孩子链表。对于图G中每个顶点Vi，把所有邻接于Vi的顶点Vj链成一个单链表，这个单链表称为顶点Vi的邻接表。
3.2邻接矩阵
邻接矩阵：图的邻接矩阵存储方式是用两个数组来表示图。一个一维数组存储图中顶点信息，一个二维数组（邻接矩阵）存储图中的边的信息。
4.图的遍历方式
4.1深度优先遍历
深度优先搜索DFS遍历类似于树的前序遍历。其基本思路是：
a) 假设初始状态是图中所有顶点都未曾访问过，则可从图G中任意一顶点v为初始出发点，首先访问出发点v，并将其标记为已访问过。
b) 然后依次从v出发搜索v的每个邻接点w，若w未曾访问过，则以w作为新的出发点出发，继续进行深度优先遍历，直到图中所有和v有路径相通的顶点都被访问到。
c) 若此时图中仍有顶点未被访问，则另选一个未曾访问的顶点作为起点，重复上述步骤，直到图中所有顶点都被访问到为止。
红色数字代表遍历的先后顺序，无向图的深度优先遍历的顶点访问序列为：V0，V1，V2，V5，V4，V6，V3，V7，V8
4.2广度优先遍历
广度优先搜索遍历BFS类似于树的按层次遍历。其基本思路是：
a) 首先访问出发点Vi
b) 接着依次访问Vi的所有未被访问过的邻接点Vi1，Vi2，Vi3，…，Vit并均标记为已访问过。
c) 然后再按照Vi1，Vi2，… ，Vit的次序，访问每一个顶点的所有未曾访问过的顶点并均标记为已访问过，依此类推，直到图中所有和初始出发点Vi有路径相通的顶点都被访问过为止。
采用广义优先搜索遍历以V0为出发点的顶点序列为：V0，V1，V3，V4，V2，V6，V8，V5，V7
5.代码实现
实现邻接表邻接矩阵及遍历操作
邻接矩阵：
#pragma once
//连接图
#include <stdio.h>
#include <vector>
#include <assert.h>
using namespace std;
template <class V,class W>
class GraphMatrix
{
private:
std::vector<V> _ver;//存放节点
std::vector<vector<W> > _edge;//存放节点的权值
bool _IsDirect;
public:
GraphMatrix(const V* pVer, size_t Size,bool isDirect = false)
:_IsDirect(false)
{
_ver.resize(Size);
_edge.resize(Size);
for (int idx = 0; idx < Size; ++idx)
{
_ver[idx] = pVer[idx];
_edge[idx].resize(Size);
}
}
//找结点的下标
int GetIndexOfVertex(const V& v)
{
for (int i = 0; i < _ver.size(); ++i)
{
if (_ver[i] == v)
return i;
}
assert(false);
return 0;
}
//添加边
void AddEdge(const V& v1,const V& v2,const W& weight)
{
int row = GetIndexOfVertex(v1);
int col = GetIndexOfVertex(v2);
_edge[row][col] = weight;
if(!_IsDirect)//无向图
{
_edge[col][row] = weight;
}
}
void Printf()
{
for (int i = 0; i < _edge.size();++i)
{
for (int j = 0; j < _edge[i].size(); ++j)
{
cout << _edge[i][j] << " ";
}
cout << endl;
}
}
};邻接表：
#pragma once
#include <stdio.h>
#include <vector>
#include <assert.h>
using namespace std;
//连接表结构
template<class W>
struct LinkEdge
{
W _weight;
size_t _srcIndex;
size_t _desIndex;
struct LinkEdge<W>* _pNext;
LinkEdge(size_t srcIndex,size_t desIndex,const W& weight)
: _srcIndex(srcIndex)
, _desIndex(desIndex)
, _weight(weight)
, _pNext(NULL)
{}
};
template <class V,class W>
class GraphLink
{
private:
std::vector<V> _vex;
std::vector<LinkEdge<W>*>_LinkTable;
bool _isDirect;
public:
GraphLink(const V* pvex, size_t size, bool isDirect = false)
:_isDirect(isDirect)
{
_vex.resize(size);
_LinkTable.resize(size,NULL);
for (size_t idx = 0; idx < size; ++idx)
_vex[idx] = pvex[idx];
}
//找结点的下标
int GetIndexOfVertex(const V& v)
{
for (int i = 0; i < _vex.size(); ++i)
{
if (_vex[i] == v)
return i;
}
assert(false);
return 0;
}
void _AddEdge(size_t srcIdx, size_t desIdx,const W& weight)
{
//采用头插的方式
LinkEdge<W>* pEdge = new LinkEdge<W>(srcIdx,desIdx,weight);
pEdge->_pNext = _LinkTable[srcIdx];
_LinkTable[srcIdx] = pEdge;
}
void AddEdge(const V& v1,const V& v2,const W& weight)
{
size_t srcIdx = GetIndexOfVertex(v1);
size_t desIdx = GetIndexOfVertex(v2);
assert(srcIdx != desIdx);
//判断是否为有向图 有向图则只插入一次 无向图要插入两次
_AddEdge(srcIdx, desIdx, weight);
if (!_isDirect)
_AddEdge(desIdx, srcIdx, weight);
}
//求某个节点的度 入度和出度的和
int GetDev(const V& v)
{
int srcIdx = GetIndexOfVertex(v);
//先求出度
int Outcount = 0;
LinkEdge<W>* pEdge = _LinkTable[srcIdx];
while (pEdge)
{
Outcount++;
pEdge = pEdge->_pNext;
}
//如果是无向图 再求入度
int Incount = 0;
if (!_isDirect)
{
for (size_t idx = 0; idx < _LinkTable.size(); ++idx)
{
if (srcIdx != idx)
{
//找到这个节点所在的链
LinkEdge<W>* pEdge = LinkEdge[idx];
while (pEdge)
{
//如果链的下一个为源 则入度加一
if (pEdge->_desIndex == srcIdx)
++Incount;
}
}
}
return Incount + Outcount;
}
}
void Printf()
{
for (size_t idx = 0; idx < _LinkTable.size(); ++idx)
{
cout << idx;
LinkEdge<W>* pEdge = _LinkTable[idx];
while (pEdge)
{
cout << "--->" << pEdge->_desIndex << "[" << pEdge->_weight << "]";
pEdge = pEdge->_pNext;
}
cout << "--->NULL" << endl;
}
cout << endl;
}
//广度优先遍历
//用队列 访问过得结点需要变为true
void BFS(const V& v)
{
cout << "广度优先遍历"<<endl;
vector<bool> visited(_vex.size(),false);
_BFS(v, visited);
//非连通结点的访问
for (size_t i = 0; i < _vex.size();++i)
{
//他为false为没有访问
if (!visited[i])
_BFS(_vex[i],visited);
}
cout << "NULL"<<endl;
}
void DFS(const V& v)
{
cout << "深度优先遍历"<<endl;
vector<bool> visited(_vex.size(),false);
int idx = GetIndexOfVertex(v);
_DFS(idx,visited);
//非连通结点的访问
for (size_t i = 0; i < _vex.size(); ++i)
{
//他为false为没有访问
if (!visited[i])
_BFS(_vex[i], visited);
}
cout << "NULL" << endl;
}
protected:
//访问过的节点需要变为true
void _BFS(const V& v,vector<bool>& vistited)
{
queue<size_t> q;
size_t idx = GetIndexOfVertex(v);
q.push(idx);
if (!vistited[idx])
{
cout << idx << "--->";
vistited[idx] = true;
q.pop();
LinkEdge<W>* pCur = _LinkTable[idx];
while (pCur)
{
q.push(pCur->_desIndex);
pCur = pCur->_pNext;
}
}
}
void _DFS(size_t idx, vector<bool>& visited)
{
if (!visited[idx])
{
cout << idx << "--->";
visited[idx] = true;
LinkEdge<W>* pCur = _LinkTable[idx];
while (pCur)
{
_DFS(pCur->_desIndex, visited);
pCur = pCur->_pNext;
}
}
}
};