高阶数据结构-图
高阶数据结构-图
图的表示
图由顶点和边构成，可分为有向图和无向图
邻接表法
图的表示方法有邻接表法和邻接矩阵法，以上图中的有向图为例，邻接表法可以表示为
A->[(B,5),(C,10)]
B->[(D,100)]
C->[(B,3)]
D->[(E,7)]
E->[NULL]
邻接表法的特点：
- 为每一个顶点维护一个顺序表，顺序表中存储与这个顶点直接相连的顶点
- 可以快速得出与一个顶点直接相连的顶点个数，时间复杂度为O(1)
- 判断两个顶点是否直接相连需要进行遍历，时间复杂度为O(N)
邻接矩阵法
使用邻接矩阵法可以表示为
| 顶点(from)/顶点(to) | A | B | C | D | E |
|---|---|---|---|---|---|
| A | 0 | 5 | 10 | NONE | NONE |
| B | NONE | 0 | NONE | 100 | NONE |
| C | NONE | 3 | 0 | NONE | NONE |
| D | NONE | NONE | NONE | 0 | 7 |
| E | NONE | NONE | NONE | NONE | 0 |
邻接矩阵法的特点：
- 维护一个二维数组，数组中的元素为顶点与顶点之间的距离
- 可以快速得出两个点之间是否存在直接相连的边，时间复杂度为O(1)
- 在判断一个顶点直接相连的顶点个数时，需要进行遍历，时间复杂度为O(N)
- 对于无向图，邻接矩阵沿对角线呈对称分布
图的结构
顶点的结构
图由顶点和边构成，顶点的结构如下
struct Edge;
struct Node {
Node(string str = "") :value(str) {}
string value;
int in = 0;
int out = 0;
unordered_set<Node*> nodes;
unordered_set<Edge*> edges;
};
value，表示顶点对应的值in，表示顶点的入度，即存在多少个顶点指向自己out，表示顶点的出度，即该顶点指出的顶点个数nodes，哈希表结构，存储一个顶点指向的所有顶点edges，哈希表结构，存储从一个顶点出发的所有边
以图中的A点为例
其value=“A”，in=0，out=2，nodes为顶点B和C，edges为权值为5的边和权值为10的边
为什么需要使用哈希表存储顶点和边？
哈希表的增删查改时间复杂度均为O(1)，在实现图相关算法时具有较好的优势
边的结构
struct Edge {
Edge(Node* f, Node* t, int w = 0) :from(f), to(t), weight(w) {}
int weight = 0;
Node* from = nullptr;
Node* to = nullptr;
};
weight，表示边的权值from，表示这条边从哪一个顶点出发to，表示这条边以哪一个顶点作为结束- 如果是无向图，使用2条有向边表示即可
图的结构
struct Graph {
unordered_map<string, Node*> nodes;
unordered_set<Edge*> edges;
};
nodes中的key为顶点代表的值，value为具体的顶点
抽象表示转化为已知结构
以下图为例
该图可以使用一个二维数组表示
vector<vector<int>> matrixGraph = {
{'A','B',5},
{'A','C',10},
{'B','D',100},
{'C','B',3},
{'D','E',7}
};
二维数组中每一个一维数组的第一个元素表示from点，第二个元素表示to点，最后一个元素表示边的权值，二维数组可以表示图，但是在实现图的相关算法不具备通用性，可以将其转化已知结构。
Graph TransforGraph(const vector<vector<int>>& matrixGraph) {
Graph ansGraph;
for (auto& elemedge : matrixGraph) {
string from, to;
from += elemedge[0];
to += elemedge[1];//获取from点与to点的值
int weight = elemedge[2];//获取边的权值
if (ansGraph.nodes.count(from) == 0) {
ansGraph.nodes[from] = new Node(from);//点不存在就创建
}
if (ansGraph.nodes.count(to) == 0) {
ansGraph.nodes[to] = new Node(to);
}
Edge* edge = new Edge(ansGraph.nodes[from], ansGraph.nodes[to], weight);
ansGraph.nodes[from]->out++;//from点的出度++
ansGraph.nodes[from]->edges.insert(edge);//将edge添加到from出发的边
ansGraph.nodes[from]->nodes.insert(ansGraph.nodes[to]);//将to点添加到from出发的点
ansGraph.nodes[to]->in++;//to点的入度++
ansGraph.edges.insert(edge);
}
return ansGraph;
}
有关图的抽象表示，均可转化为已知结构，以便于实现图的相关算法
图的算法
宽度优先遍历
图结构中可能存在环，宽度优先遍历(bfs)时需要使用哈希表以避免顶点重复进入队列
void bfs(Node* start) {//从start开始进行宽度优先遍历
queue<Node*> nodeQ;
unordered_set<Node*> nodeSet;
nodeQ.push(start);
while (!nodeQ.empty()) {
Node* cur = nodeQ.front();
nodeQ.pop();
if (nodeSet.count(cur) == 0) {//表示之前没有遍历过这个顶点
cout << cur->value << endl;//访问该顶点
nodeSet.insert(cur);//将该顶点加入set,防止重复遍历
for (Node* node : cur->nodes) {
if (nodeSet.count(node) == 0) {
nodeQ.push(node);
}
}
}
}
}
深度优先遍历
图的深度优先遍历(dfs)：
- 使用哈希表记录已经遍历过的顶点
- 使用栈记录深度优先遍历的路径
- 在出栈时，已经遍历过的顶点直接跳过
void dfs(Node* start) {
stack<Node*> nodeStack;
unordered_set<Node*> nodeSet;
nodeStack.push(start);
cout << start->value << endl;//深度优先遍历在入栈时对顶点进行处理
nodeSet.insert(start);
while (!nodeStack.empty()) {
Node* Topnode = nodeStack.top();//取出栈顶元素
nodeStack.pop();
for (Node* node : Topnode->nodes) {
if (nodeSet.count(node) == 0) {//判断是否已经遍历过
cout << node->value << endl;//访问下一层的元素
nodeSet.insert(node);
nodeStack.push(Topnode);
nodeStack.push(node);//将路径压入栈中
break;//去往下一层
}
}
}
}
拓扑排序
一个项目可能存在多个模块，模块之间存在一定的依赖关系，可以用图表示
例如上图，模块B依赖于模块A，模块C依赖于模块A和B，模块D依赖于模块A和C，该项目在进行编译时的顺序应该是A、B、C、D
拓扑排序可以用于确定各个模块之间的编译顺序：
- 寻找入度(in)为0的模块，这些模块不依赖于任何模块，可以直接进行编译
- 擦除入度为0的模块对整个项目的影响，入度为0的模块，其指向的模块入度减一
- 重复步骤2，直到所有模块入度均为0
- 项目中不能存在循环依赖
queue<Node*> TopologyAlgorithm(const Graph& graph) {
queue<Node*> ansQ;
unordered_map<Node*, int> inMap;//保存所有顶点的入度,不直接修改Node
queue<Node*> zeroQ;//保存入度为0的顶点
for (auto& [value, node] : graph.nodes) {
inMap.insert(std::make_pair(node, node->in));
if (node->in == 0) {
zeroQ.push(node);
}
}
while (!zeroQ.empty()) {
Node* zeroNode = zeroQ.front();
zeroQ.pop();
ansQ.push(zeroNode);
for (Node* node : zeroNode->nodes) {
if (!--inMap[node]) {//在inMap中进行修改
zeroQ.push(node);
}
}
}
return ansQ;
}
最小生成树
最小生成树指的是使用最小的代价使得一个图中的所有顶点连通，最小生成树仅适用于无向图。
生成最小生成树的算法有Kruskal算法和Prim算法，Kruskal算法侧重于从边的角度考虑，Prim算法侧重于从顶点的角度进行考虑
Kruskal算法
Kruskal算法生成最小生成树的流程如下：
- 将所有的边按照权值由小到大放入小根堆
- 从小根堆弹出权值最小的边，判断这条边的2个顶点是否在同一个集合，若不在，则将这两个顶点所在的集合合并为一个集合，并将这条边加入最终结果；若在，直接舍弃这条边
- 重复步骤2，直到小根堆中没有元素
使用Kruskal算法生成最小生成树需要使用并查集结构，并查集结构可以快速判断2个元素是否在同一个集合，以及快速合并2个集合
并查集
- 初始时，并查集中每一个元素各自为一个集合，其父节点均为自身
- 进行集合合并时，只需将一个集合的父节点指向另外一个集合的父节点
- 查看2个元素是否处于同一个集合时，只需检查它们最顶层的父节点是否一样
- 在寻找一个节点最顶层的父节点时，可以将路径上所有节点的父修改为顶层父节点
并查集的实现
template<typename T>
class UnionFindSet {
public:
template<class Iter>
UnionFindSet(Iter first, Iter last) {
for (auto it = first; it != last; it++) {
fatherMap[*it] = *it;
sizeMap[*it] = 1;
}
}
bool IsSameSet(T left, T right) {
if (fatherMap.count(left) == 0 || fatherMap.count(right) == 0) {
return false;
}
return TopLevelNode(left) == TopLevelNode(right);//顶层父节点是否相同
}
void Union(T left, T right) {//合并集合
if (fatherMap.count(left) == 0 || fatherMap.count(right) == 0) {
return;
}
T ltop = TopLevelNode(left);
T rtop = TopLevelNode(right);
if (ltop != rtop) {
size_t lsize = sizeMap[ltop];
size_t rsize = sizeMap[rtop];
T maxSet = lsize > rsize ? ltop : rtop;
T minSet = lsize > rsize ? rtop : ltop;
sizeMap[maxSet] += sizeMap[minSet];//将小集合合并到大集合
fatherMap[minSet] = maxSet;
sizeMap.erase(minSet);
}
}
size_t SetSize(T node) {//获取一个元素所在集合的元素个数
if (fatherMap.count(node) == 0) {
return -1;
}
return sizeMap[fatherMap[node]];
}
private:
T TopLevelNode(T node) {//获取一个顶点最顶层的父节点
vector<T> nodes;
while (node != fatherMap[node]) {
nodes.push_back(node);
node = fatherMap[node];
}
for (auto& it : nodes) {
fatherMap[it] = node;//压缩路径
}
return node;
}
private:
unordered_map<T, T> fatherMap;//记录每一个顶点的直接父节点
unordered_map<T, size_t> sizeMap;//记录每一个大集合中元素的个数
};
使用并查集实现Kruskal算法
使用并查集实现Kruskal算法时，返回值为所有选中的边，根据边即可获取最小生成树的所有信息，需要注意的是，虽然Kruskal算法适用于无向图，但返回值为有向边，这并不影响最小生成树的结构，因为有向边中包含from点、to点、权值
vector<Edge*> Kruskal(const Graph& graph) {
vector<Edge*> ans;
vector<Node*> nodes;
for (auto& [value, node] : graph.nodes) {
nodes.push_back(node);
}
UnionFindSet<Node*> nodeUFS(nodes.begin(), nodes.end());
auto EdgeCompare = [](const Edge* l, const Edge* r) {
return l->weight > r->weight;
};
priority_queue<Edge*, deque<Edge*>, decltype(EdgeCompare)> edgeHeap(graph.edges.begin(), graph.edges.end(), EdgeCompare);//graph是无向图,edgeHeap中存在权值相同,方向相反的边
while (!edgeHeap.empty()) {
Edge* edge = edgeHeap.top();
edgeHeap.pop();
Node* from = edge->from;
Node* to = edge->to;
if (!nodeUFS.IsSameSet(from, to)) {//选择这条边
ans.push_back(edge);
nodeUFS.Union(from, to);
}
}
return ans;
}
Prim算法
Prim算法生成最小生成树侧重于从顶点出发考虑问题，不需要使用并查集
Prim算法流程
- 任意选取一个顶点作为起点，将该顶点出发的边加入小根堆，并将这个顶点添加到哈希表
- 从小根堆中选取权值最小的边，若这条边的to点在哈希表中，跳过这条边，否则以to点作为中心，将与to点相连的边添加到小根堆
- 将边向小根堆添加的过程中，应该检查这个边的to点是否在哈希表中，若不在，才可以添加
Prim算法的实现
vector<Edge*> Prim(const Graph& graph) {
vector<Edge*> ans;
Node* start = graph.nodes.begin()->second;//任选一个顶点作为起点
unordered_set<Node*> nodeSet;
nodeSet.insert(start);
auto EdgeCompare = [](const Edge* l, const Edge* r) {
return l->weight > r->weight;
};
priority_queue<Edge*, deque<Edge*>, decltype(EdgeCompare)> edgeHeap(EdgeCompare);
for (Edge* edge : start->edges) {
edgeHeap.push(edge);//将从顶点出发的边添加到小根堆
}
while (!edgeHeap.empty()) {
Edge* edge = edgeHeap.top();
Node* to = edge->to;
edgeHeap.pop();
if (nodeSet.count(to) == 0) {//to点没有被添加到哈希表
nodeSet.insert(to);
ans.push_back(edge);
for (Edge* edge : to->edges) {
edgeHeap.push(edge);
}
}
}
return ans;
}
Dijikstra算法
Dijikstra(迪杰斯特拉)算法用于寻找最短路径，采用动态规划的思想(本质是逐步尝试)
图中A到B的最短路径是5，A到C的最短路径是先通过B在达到C，为15。
Dijikstra寻找最短路径的的思想：每次寻找距离最近的点，以该点作为中心尝试进行更新
Dijikstra算法的实现
pair<unordered_map<Node*, list<Node*>>, unordered_map<Node*, int>> Dijikstra(Node* base) {//求base点到各个点的最短距离
unordered_map<Node*, int> distanceMap;//distanceMap[a]表示base点到a点的距离,若a不在distanceMap中,表示base点与a点的距离为无穷
unordered_map<Node*, list<Node*>> pathMap;//pathMap[a]表示base点到a点的路径
unordered_set<Node*> lockedNode;//表示已经确定最短距离的点
auto getMinAndUnlockedNode = [&]() {//找到distanceMap中距离最小的点,且这个点没有被锁定
Node* ans = nullptr;
for (auto& [node, distance] : distanceMap) {
if (lockedNode.count(node) == 0) {
ans = ans == nullptr ? node : (distanceMap[ans] > distance ? node : ans);
}
}
return ans;
};
pathMap[base].push_back(base);
distanceMap[base] = 0;//base->base
Node* cur;
while (cur = getMinAndUnlockedNode()) {
lockedNode.insert(cur);
for (Edge* edge : cur->edges) {
Node* to = edge->to;
//状态转移方程
if (distanceMap.count(to) == 0) {
pathMap[to] = pathMap[cur];
pathMap[to].push_back(to);
distanceMap[to] = distanceMap[cur] + edge->weight;
}
else {
if (distanceMap[cur] + edge->weight < distanceMap[to]) {
pathMap[to] = pathMap[cur];
pathMap[to].push_back(to);
distanceMap[to] = distanceMap[cur] + edge->weight;
}
}
}
}
return std::make_pair(pathMap, distanceMap);
}