本文详细介绍了如何使用C++实现图的邻接矩阵，包括初始化、第一个邻接顶点和下一个邻接顶点的操作。此外，还讲解了深度优先搜索和广度优先搜索的算法，并讨论了连通分量的概念。最后，提到了图的主函数与测试方法，以及图在最小生成树、最短路径等问题上的应用。
数据结构 - 图 II (Graph II)
本文将介绍图的基础知识，并用C++实现它。
它包含两部分：
-
编程基础 - 图 I (Graph I) ：存储结构
-
编程基础 - 图 II (Graph II) ：实现完整的邻接矩阵并遍历（本文）
在查看本文之前，需要一些数据结构和程序语言的基础。
尤其是“二维数组”、“矩阵”、“矩阵的压缩(matrix)”。一些遍历和应用的内容还需要“栈(stack)”，“队列(queue)”，“二叉树(binary tree)”等的知识。
文章目录
3 实现邻接矩阵 (Implementing Adjacency Matrix)
我们有了邻接矩阵的结构，但在四个结构中，只有它的顶点没有使用结构。我们为了保持一致，也为它建立一个结构。
template<typename T>
class AMVertexNode
{
public:
T element;
AMVertexNode(const T& e)
{
element = e;
}
};
然后这四种结构，虽然结构不同，但方法的作用全部都是一样的，所以建立一个抽象类（Abstract Class）是一个非常棒的想法。即
// 图接口
template<typename TValue, template<typename TValue> class TVertex>
class IGraph
{
public:
static constexpr double INFINITE_WEIGHT
= std::numeric_limits<double>::max(); // 权值无穷符号
protected: // Fields
bool m_Oriented; // 有向图标识
double m_DefaultWeight; // 不连通的权重，即0或无穷
std::vector<TVertex<TValue>*> m_Vertexes; // 顶点列表
protected: // Constructors
IGraph(bool oriented); // 构造函数
virtual ~IGraph(); // 析构函数
protected: // Properties
virtual TVertex<TValue>* GetVertexNode(int index); // 获取顶点
virtual bool PutVertexNode(int index, TVertex<TValue>* vertex); // 设置顶点
virtual bool InsertVertexNode(TVertex<TValue>* vertex); // 插入顶点
virtual bool InsertVertexNode(int index, TVertex<TValue>* vertex); // 插入顶点
public: // Properties
bool IsOriented(); // 是否是有向图
double GetDefaultWeight(); // 获取不连通的权重
void PutDefaultWeight(double defaultWeight); // 设置不连通的权重
virtual void ResetDefaultWeight(); // 重置不连通的权重
bool IsEmpty(); // 是否空
virtual int GetVertexCount(); // 获取顶点数量
// 省略，其它相同属性
public: // Methods
// 省略，其它相同方法
}
- 其中的基本属性操作就不再阐述。
在邻接矩阵中，我们继承它：
// 邻接矩阵
template<typename T>
class AdjacencyMatrix : virtual public IGraph<T, AMVertexNode>
{
protected:
std::vector<std::vector<double>> m_Weights; // 边的关系，邻接矩阵
// 省略内容
}
3.1 初始化 (Initialize)
初始化包含初始化顶点，和初始化边。
在初始化顶点时，就已经确定了边的长度，即邻接矩阵的长宽都是顶点的数量。
初始化顶点：
// Author: https://blog.csdn.net/DarkRabbit
// Graph -> Adjacency Matrix
// 初始化顶点
// params:
// vertexElements: 顶点的值
// return:
// bool: 是否初始化成功
template<typename T>
bool AdjacencyMatrix<T>::InitializeVertexes(const std::vector<T>& vertexElements)
{
if (!this->IsEmpty())
{
this->DestroyAllVertexNodes();
}
int size = vertexElements.size();
this->m_Vertexes = std::vector<AMVertexNode<T>*>(size, 0);
for (int i = 0; i < size; i++)
{
AMVertexNode<T>* vertex = new AMVertexNode<T>(vertexElements[i]);
this->PutVertexNode(i, vertex);
}
// 初始化边长宽，并全部赋值成 0或无穷
m_Weights = std::vector<std::vector<double>>(size, std::vector<double>(size, this->GetDefaultWeight()));
return true;
}
而在初始化边时，我们要确保路径和权值的长度是相等的，即每两个顶点的路径都有权值。
初始化边：
// Author: https://blog.csdn.net/DarkRabbit
// Graph -> Adjacency Matrix
// 初始化边
// params:
// paths: 起始到结束的路径
// weights: 权重
// return:
// bool: 是否初始化成功
template<typename T>
bool AdjacencyMatrix<T>::InitializeWeights(const std::vector<std::pair<int, int>> paths,
const std::vector<double>& weights)
{
if (paths.size() != weights.size())
{
return false;
}
bool oriented = this->IsOriented(); // 是否有向图
for (int i = 0; i < paths.size(); i++)
{
this->TryPutWeight(paths[i].first, paths[i].second, weights[i]);
if (!oriented)
{
this->TryPutWeight(paths[i].second, paths[i].first, weights[i]);
}
}
return true;
}
// 用同一个权重初始化边
// params:
// paths: 起始到结束的路径
// return:
// bool: 是否初始化成功
template<typename T>
bool AdjacencyMatrix<T>::InitializeUndirectedWeights(const std::vector<std::pair<int, int>> paths,
double weight)
{
bool oriented = this->IsOriented();
for (int i = 0; i < paths.size(); i++)
{
this->TryPutWeight(paths[i].first, paths[i].second, weight);
if (!oriented)
{
this->TryPutWeight(paths[i].second, paths[i].first, weight);
}
}
return true;
}
3.2 第一个邻接顶点 (First Adjacency)
我们只需要遍历邻接矩阵对应的行，取其中不为0或无穷的顶点。
其代码为：
// Author: https://blog.csdn.net/DarkRabbit
// Graph -> Adjacency Matrix
// 查找第一条边连接的顶点
// params:
// index; 顶点下标
// return:
// int: 找到的邻接顶点下标，没有找到返回-1
template<typename T>
int AdjacencyMatrix<T>::FirstNeighbor(int index)
{
int size = this->GetVertexCount();
if (index < 0 || index >= size)
{
return -1;
}
int find = -1;
for (int i = 0; i < size; i++)
{
if (m_Weights[index][i] != this->GetDefaultWeight())
{
find = i;
break;
}
}
return find;
}
3.3 下一个邻接顶点 (Next Adjacency)
我们同样搜索行，只是起点不是0，而是邻接顶点的下标，来搜索它之后的下标。
其代码为：
// Author: https://blog.csdn.net/DarkRabbit
// Graph -> Adjacency Matrix
// 查找下一条边连接的顶点
// params:
// index; 顶点下标
// neighborIndex: 邻接顶点下标
// return:
// int: 找到的邻接的邻接顶点下标，没有找到返回-1
template<typename T>
int AdjacencyMatrix<T>::NextNeighbor(int index, int neighborIndex)
{
int size = this->GetVertexCount();
if (index < 0 || index >= size || neighborIndex < 0 || neighborIndex >= size)
{
return -1;
}
int find = -1;
for (int i = neighborIndex + 1; i < size; i++)
{
if (m_Weights[index][i] != this->GetDefaultWeight())
{
find = i;
break;
}
}
return find;
}
4 图的遍历 (Graph Traversal)
图的遍历，主要是指在连通图中的遍历，从一顶点出发，沿着路径访问图中所有的顶点，且每个顶点只被访问一次。
由于图中可能会有回路，所以在回到访问过的顶点时，需要加以判断，这就需要我们为每个顶点添加一个标识变量。
图的遍历的分类：
-
深度优先（Depth First Search，DFS）
-
广度优先（Breadth First Search， BFS）
4.1 深度优先搜索 (Depth First Search)
深度优先搜索基本思路：
-
（1）由某一起始点出发，沿某一条路径访问第一个邻接顶点；
-
（2）再从此邻接顶点出发，访问没有访问过的此顶点的邻接顶点；
-
（3）如果周围邻接顶点都访问过或没有顶点，则退回一步查找周围邻接顶点；
-
（4）循环过程，直到全部顶点访问。
深度优先遍历 类似于二叉树的先序遍历 ，非递归算法通常使用栈 。
其C++代码为：
// Author: https://blog.csdn.net/DarkRabbit
// Abstract Graph
// 深度优先遍历，内部递归
// params:
// index: 当前访问顶点
// isVisited: 访问标识
// pVisit: 访问方法
template<typename TValue, template<typename TValue> class TVertex>
void IGraph<TValue, TVertex>::DepthFirstSearchRecursion(int index,
std::vector<bool>& isVisited,
void(*pVisit)(TVertex<TValue>&))
{
TVertex<TValue>* vertex = this->GetVertexNode(index); // 取顶点
(*pVisit)(*vertex); // 访问顶点
isVisited[index] = true; // 设置标记，访问过了
// 从第一个邻接顶点开始搜索邻接
for (int neighbor = this->FirstNeighbor(index);
neighbor != -1;
neighbor = this->NextNeighbor(index, neighbor))
{
if (!isVisited[neighbor])
{
this->DepthFirstSearchRecursion(neighbor, isVisited, pVisit);
}
}
}
// 深度优先遍历
// params:
// pVisit: 访问方法
template<typename TValue, template<typename TValue> class TVertex>
void IGraph<TValue, TVertex>::DepthFirstSearch(void(*pVisit)(TVertex<TValue>&))
{
if (this->IsEmpty() || 0 == pVisit)
{
return;
}
int size = this->GetVertexCount();
std::vector<bool> isVisited = std::vector<bool>(size, false); // 访问标记
this->DepthFirstSearchRecursion(0, isVisited, pVisit);
}
4.2 广度优先搜索 (Breadth First Search)
广度优先搜索基本思路：
-
（1）由某一起始点出发，访问所有邻接顶点；
-
（2）再从其中一个邻接顶点出发，访问其所有邻接结点；
-
（3）循环过程，直到全部顶点访问。
广度优先遍历 类似于二叉树的层序遍历 ，非递归算法通常使用队列 。
其C++代码为：
// 广度优先遍历
// params:
// pVisit: 访问方法
template<typename TValue, template<typename TValue> class TVertex>
void IGraph<TValue, TVertex>::BreadthFirstSearch(void(*pVisit)(TVertex<TValue>&))
{
if (this->IsEmpty() || 0 == pVisit)
{
return;
}
int size = this->GetVertexCount();
std::vector<bool> isVisited = std::vector<bool>(size, false); // 访问标记
(*pVisit)(*(this->GetVertexNode(0))); // 访问第一个顶点
isVisited[0] = true; // 第一个顶点访问过了
std::queue<int> vertexQueue; // 定义队列，储存访问过的顶点
vertexQueue.push(0); // 加入第一个顶点
int index; // 要访问谁的邻接
while (!vertexQueue.empty())
{
index = vertexQueue.front();
vertexQueue.pop();
// 从第一个邻接顶点开始访问邻接
for (int neighbor = this->FirstNeighbor(index);
neighbor != -1;
neighbor = this->NextNeighbor(index, neighbor))
{
if (!isVisited[neighbor])
{
(*pVisit)(*(this->GetVertexNode(neighbor))); // 访问邻接顶点
isVisited[neighbor] = true; // 访问过了
vertexQueue.push(neighbor); // 入队
}
}
}
}
5 连通分量 (Connected Component)
当无向图是非连通图时，从图中任意一点触发，利用遍历算法不可能遍历到所有的点，只能访问到该顶点所在子图的所有顶点，此子图为最大连通子图，也称连通分量。
求连通分量：
- 对图中每一个顶点进行遍历；
- 若顶点访问过，则此顶点所在子图已经求过连通分量，继续下一个顶点；
- 若未被访问过，则通过遍历求连通分量。
对非连通的无向图，所有连通分量的生成树，能组成非连通图的生成森林。
对于有向图，从不同的顶点出发，通过遍历可以得到不同的生成树。
6 主函数与测试 (Main Methods and Testing)
主要测试遍历，采用邻接矩阵来计算。
其它存储格式同理。
6.1 主函数 (Main Methods)
#include "abstract_graph.h"
#include "adjacency_matrix.h"
#include <vector>
#include <unordered_map>
#include <iostream>
using namespace std;
typedef Graphs::AMVertexNode<int> AMVertexInt;
typedef Graphs::AdjacencyMatrix<int> AMGraphInt;
void TestAdjacencyMatrix();
int main()
{
TestAdjacencyMatrix();
system("pause");
return 0;
}
// 打印邻接矩阵
template<class TGraph>
void PrintMatrix(TGraph& graph);
// 打印元素值
template<class TVertex>
void PrintVisitedVertexElement(TVertex& vertex)
{
cout << (char)(vertex.element + 'A') << ' ';
}
// 邻接矩阵
void TestAdjacencyMatrix()
{
vector<int> amVec;
for (int i = 0; i < 6; i++)
{
amVec.push_back(i);
}
AMGraphInt amGraphs[2] = { AMGraphInt(amVec, false), AMGraphInt(amVec, true) };
amGraphs[0].InitializeUndirectedWeights
(
{
{0, 1}, {0, 4}, {1, 3}, {1, 4}, {1, 5}, {2, 3}, {2, 5}
},
1.0
);
amGraphs[1].InitializeWeights
(
{
{0, 1}, {0, 4}, {1, 0}, {1, 3}, {1, 4}, {1, 5}, {2, 3}, {2, 5}, {5, 4}
},
{
6, 3, 2, 1, 9, 0, 2, 0, 3
}
);
cout << "----------邻接矩阵----------" << endl;
cout << "邻接矩阵输入顺序：" << endl;
for (int i = 0; i < amVec.size(); i++)
{
cout << (char)(amVec[i] + 'A') << ' ';
}
cout << endl << endl;
cout << "无向图：" << endl;
cout << "邻接矩阵：" << endl;
PrintMatrix(amGraphs[0]);
cout << "邻接矩阵——深度优先遍历：" << endl;
amGraphs[0].DepthFirstSearch(PrintVisitedVertexElement);
cout << endl;
cout << "邻接矩阵——广度优先遍历：" << endl;
amGraphs[0].BreadthFirstSearch(PrintVisitedVertexElement);
cout << endl;
cout << endl;
cout << "有向图" << endl;
cout << "邻接矩阵：" << endl;
PrintMatrix(amGraphs[1]);
cout << "邻接矩阵——深度优先遍历：" << endl;
amGraphs[1].DepthFirstSearch(PrintVisitedVertexElement);
cout << endl;
cout << "邻接矩阵——广度优先遍历：" << endl;
amGraphs[1].BreadthFirstSearch(PrintVisitedVertexElement);
cout << endl;
cout << "--------------------" << endl;
}
6.2 打印结果 (Print Output)
----------邻接矩阵----------
邻接矩阵输入顺序：
A B C D E F
无向图：
邻接矩阵：
A B C D E F
A 0 1 0 0 1 0
B 1 0 0 1 1 1
C 0 0 0 1 0 1
D 0 1 1 0 0 0
E 1 1 0 0 0 0
F 0 1 1 0 0 0
邻接矩阵——深度优先遍历：
A B D C F E
邻接矩阵——广度优先遍历：
A B E D F C
有向图
邻接矩阵：
A B C D E F
A . 6 . . 3 .
B 2 . . 1 9 0
C . . . 2 . 0
D . . . . . .
E . . . . . .
F . . . . 3 .
邻接矩阵——深度优先遍历：
A B D E F
邻接矩阵——广度优先遍历：
A B E D F
--------------------
请按任意键继续. . .
7 图的应用实例 (Graph Examples)
实例，如果有补充将会在这里更新链接。
-
最小生成树 (Minimum Spanning Tree) ：主要应用在交通规划，电力系统规划，通信领域等需要铺设网络的方向。
- 克鲁斯卡尔算法 (Kruskal)
- 普利姆算法 (Prim)
-
最短路径 (Shortest Path) ：这个不用说了，非常常用；
- 迪杰斯特拉算法 (Dijkstra)
- 弗洛伊德算法 (Floyed)
A星算法 (A Star)贝尔曼-福特算法的队列优化形式 (Bellman-Ford using queue optimization)
-
- AOV网络 (Activity On Vertex network)，拓扑排序 (Topological-Sort)
常用来表示各种优先级关系； - AOE网络 (Activity On Edge Network)，关键路径 (Critical Path)
常用来描述和分析一项工程的计划和实施过程。
- AOV网络 (Activity On Vertex network)，拓扑排序 (Topological-Sort)
扫一扫
484
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
