参考：最小生成树(Kruskal(克鲁斯卡尔)和Prim(普里姆))算法动画演示
最小生成树的特征
- 选取的边是图中权值较小的边
- 所有边连接后不构成回路
问题
既然最小生成树关心的是如何选择 n-1 条边，那么是否可以直接以边为核心进行算法设计？
简单尝试
由 4 个顶点构成的图，选择 3 条权值最小的边
需要解决的问题
如何判断新选择的边与已选择的边是否构成回路?
产生回路：
技巧：前驱标记数组
- 定义数组： Array<int> p(vCount());
数组元素的定义：
- p[n] 表示顶点 n 在边的连接通路上的另一端顶点
示例分析：使用标记数组选择边
回路边时：
最小生成树算法的核心步骤（Kruskal）
- 定义前驱标记数组： Array<int> p(vCount())
- 获取当前图中的所有边，并保存于 edges 数组中
- 对数组 edges 按照权值进行排序
- 利用 p 数组在 edges 数组选择前 n-1 不构成回路的边
Kruskal 算法流程
关键的 find 查找函数
int find(Array<int> &p, int v)
{
while (p[v] != -1)
{
v = p[v];
}
return v;
}编程实验：最小生成树算法
文件：Graph.h
#ifndef GRAPH_H
#define GRAPH_H
#include "Object.h"
#include "SharedPointer.h"
#include "DynamicArray.h"
#include "LinkQueue.h"
#include "LinkStack.h"
#include "Sort.h"
namespace DTLib
{
template <typename E>
struct Edge : public Object
{
int b;
int e;
E data;
Edge(int i=-1, int j=-1) : b(i), e(j)
{
}
Edge(int i, int j, const E &value) : b(i), e(j), data(value)
{
}
bool operator == (const Edge &obj)
{
return (b == obj.b) && (e == obj.e);
}
bool operator != (const Edge &obj)
{
return !(*this == obj);
}
bool operator < (const Edge &obj)
{
return (data < obj.data);
}
bool operator > (const Edge &obj)
{
return (data > obj.data);
}
};
template <typename V, typename E>
class Graph : public Object
{
public:
virtual V getVertex(int i) const = 0;
virtual bool getVertex(int i, V &value) const = 0;
virtual bool setVertex(int i, const V &value) = 0;
virtual SharedPointer<Array<int>> getAdjacent(int i) const = 0;
virtual bool isAdjacent(int i, int j) const = 0;
virtual E getEdge(int i, int j) const = 0;
virtual bool getEdge(int i, int j, E &value) const = 0;
virtual bool setEdge(int i, int j, const E &value) = 0;
virtual bool removeEdge(int i, int j) = 0;
virtual int vCount() const = 0;
virtual int eCount() = 0;
virtual int OD(int i) = 0;
virtual int ID(int i) = 0;
virtual int TD(int i)
{
return OD(i) + ID(i);
}
bool asUndirected()
{
bool ret = true;
for (int i=0; i<vCount() && ret; ++i)
{
for (int j=0; j<vCount() && ret; ++j)
{
if (isAdjacent(i, j))
{
ret = isAdjacent(j, i) && (getEdge(i, j) == getEdge(j, i));
}
}
}
return ret;
}
SharedPointer<Array<int>> BFS(int i)
{
DynamicArray<int> *ret = nullptr;
if ((0 <= i) && (i < vCount()))
{
LinkQueue<int> q;
LinkQueue<int> r;
DynamicArray<bool> visited(vCount());
for (int j=0; j<visited.length(); ++j)
{
visited[j] = false;
}
q.add(i);
while (q.length() > 0)
{
int v = q.front();
q.remove();
if (!visited[v])
{
SharedPointer<Array<int>> aj = getAdjacent(v);
for (int j=0; j<aj->length(); ++j)
{
q.add((*aj)[j]);
}
r.add(v);
visited[v] = true;
}
}
ret = toArray(r);
}
else
{
THROW_EXCEPTION(InvalidParameterExcetion, "Parameter i is invalid ...");
}
return ret;
}
#ifdef DFS_R
SharedPointer<Array<int>> DFS(int i) // 递归版深度优先遍历
{
DynamicArray<int> *ret = nullptr;
if ((0 <= i) && (i < vCount()))
{
LinkQueue<int> r;
DynamicArray<bool> visited(vCount());
for (int j=0; j<vCount(); ++j)
{
visited[j] = false;
}
DFP(i, visited, r);
ret = toArray(r);
}
else
{
THROW_EXCEPTION(InvalidParameterExcetion, "Parameter i is invalid ...");
}
return ret;
}
#else
SharedPointer<Array<int>> DFS(int i)
{
DynamicArray<int> *ret = nullptr;
if ((0 <= i) && (i < vCount()))
{
LinkStack<int> s;
LinkQueue<int> r;
DynamicArray<bool> visited(vCount());
for (int j=0; j<visited.length(); ++j)
{
visited[j] = false;
}
s.push(i);
while (s.size() > 0)
{
int v = s.top();
s.pop();
if (!visited[v])
{
SharedPointer<Array<int>> aj = getAdjacent(v);
for (int j=aj->length()-1; j>=0; --j)
{
s.push((*aj)[j]);
}
r.add(v);
visited[v] = true;
}
}
ret = toArray(r);
}
else
{
THROW_EXCEPTION(InvalidParameterExcetion, "Parameter i is invalid ...");
}
return ret;
}
#endif
SharedPointer<Array<Edge<E>>> prim(const E &LIMIT, const bool MINIMUM = true)
{
LinkQueue<Edge<E>> ret;
if (asUndirected())
{
DynamicArray<int> adjVex(vCount());
DynamicArray<bool> mark(vCount());
DynamicArray<E> cost(vCount());
SharedPointer<Array<int>> aj = nullptr;
bool end = false;
int v = 0;
for (int i=0; i<vCount(); ++i)
{
adjVex[i] = -1;
mark[i] = false;
cost[i] = LIMIT;
}
mark[v] = true;
aj = getAdjacent(v);
for (int i=0; i<aj->length(); ++i)
{
cost[(*aj)[i]] = getEdge(v, (*aj)[i]);
adjVex[(*aj)[i]] = v;
}
for (int i=0; i<vCount() && !end; ++i)
{
E m = LIMIT;
int k = -1;
for (int j=0; j<vCount(); ++j)
{
if (!mark[j] && (MINIMUM ? (m > cost[j]) : (m < cost[j])))
{
m = cost[j];
k = j;
}
}
end = (k == -1);
if (!end)
{
ret.add(Edge<E>(adjVex[k],k, getEdge(adjVex[k],k)));
mark[k] = true;
aj = getAdjacent(k);
for (int j=0; j<aj->length(); ++j)
{
if (!mark[(*aj)[j]] && (MINIMUM ? (getEdge(k, (*aj)[j]) < cost[(*aj)[j]]) : (getEdge(k, (*aj)[j]) > cost[(*aj)[j]])))
{
cost[(*aj)[j]] = getEdge(k, (*aj)[j]);
adjVex[(*aj)[j]] = k;
}
}
}
}
}
else
{
THROW_EXCEPTION(InvalidOpertionExcetion, "Prim operator is for undirected grap only ...");
}
if (ret.length() != (vCount() - 1))
{
THROW_EXCEPTION(InvalidOpertionExcetion, "No enough edge for prim operation ...");
}
return toArray(ret);
}
SharedPointer<Array<Edge<E>>> Kruskal( const bool MINIMUM = true)
{
LinkQueue<Edge<E>> ret;
DynamicArray<int> p(vCount());
SharedPointer<Array<Edge<E>>> edges = getUndirectedEdges();
for (int i=0; i<p.length(); ++i)
{
p[i] = -1;
}
Sort::Shell(*edges, MINIMUM);
for (int i=0; (i<edges->length()) && (ret.length() < (vCount()-1)); ++i)
{
int b = find(p, (*edges)[i].b);
int e = find(p, (*edges)[i].e);
if (b != e)
{
p[e] = b;
ret.add((*edges)[i]);
}
}
if (ret.length() != vCount() - 1)
{
THROW_EXCEPTION(InvalidOpertionExcetion, "No enough edges for Kruskal operation ...");
}
return toArray(ret);
}
protected:
template <typename T>
DynamicArray<T>* toArray(LinkQueue<T> &queue)
{
DynamicArray<T> *ret = new DynamicArray<T>(queue.length());
if (ret != nullptr)
{
for (int i=0; i<ret->length(); ++i, queue.remove())
{
ret->set(i, queue.front());
}
}
else
{
THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create ret obj ...");
}
return ret;
}
#ifdef DFS_R
void DFP(int i, DynamicArray<bool> &visited, LinkQueue<int>& queue)
{
if (!visited[i])
{
queue.add(i);
visited[i] = true;
SharedPointer<Array<int>> aj = getAdjacent(i);
for (int j=0; j<aj->length(); ++j)
{
DFP((*aj)[j], visited, queue);
}
}
}
#endif
int find(Array<int> &p, int v)
{
while (p[v] != -1)
{
v = p[v];
}
return v;
}
SharedPointer<Array<Edge<E>>> getUndirectedEdges()
{
DynamicArray<Edge<E>> *ret = nullptr;
if (asUndirected())
{
LinkQueue<Edge<E>> queue;
for (int i=0; i<vCount(); ++i)
{
for (int j=0; j<vCount(); ++j)
{
if (isAdjacent(i, j))
{
queue.add(Edge<E>(i, j, getEdge(i, j)));
}
}
}
ret = toArray(queue);
}
else
{
THROW_EXCEPTION(InvalidOpertionExcetion, "This function is for undirected graph only ...");
}
return ret;
}
};
}
#endif // GRAPH_H文件：main.cpp
#include <iostream>
#include "MatrixGraph.h"
#include "ListGraph.h"
using namespace std;
using namespace DTLib;
template< typename V, typename E >
Graph<V, E>& GraphEasy()
{
static MatrixGraph<4, V, E> g;
g.setEdge(0, 1, 1);
g.setEdge(1, 0, 1);
g.setEdge(0, 2, 3);
g.setEdge(2, 0, 3);
g.setEdge(1, 2, 1);
g.setEdge(2, 1, 1);
g.setEdge(1, 3, 4);
g.setEdge(3, 1, 4);
g.setEdge(2, 3, 1);
g.setEdge(3, 2, 1);
return g;
}
template< typename V, typename E >
Graph<V, E>& GraphComplex()
{
static ListGraph<V, E> g(9);
g.setEdge(0, 1, 10);
g.setEdge(1, 0, 10);
g.setEdge(0, 5, 11);
g.setEdge(5, 0, 11);
g.setEdge(1, 2, 18);
g.setEdge(2, 1, 18);
g.setEdge(1, 8, 12);
g.setEdge(8, 1, 12);
g.setEdge(1, 6, 16);
g.setEdge(6, 1, 16);
g.setEdge(2, 3, 22);
g.setEdge(3, 2, 22);
g.setEdge(2, 8, 8);
g.setEdge(8, 2, 8);
g.setEdge(3, 8, 21);
g.setEdge(8, 3, 21);
g.setEdge(3, 6, 24);
g.setEdge(6, 3, 24);
g.setEdge(3, 7, 16);
g.setEdge(7, 3, 16);
g.setEdge(3, 4, 20);
g.setEdge(4, 3, 20);
g.setEdge(4, 5, 26);
g.setEdge(5, 4, 26);
g.setEdge(4, 7, 7);
g.setEdge(7, 4, 7);
g.setEdge(5, 6, 17);
g.setEdge(6, 5, 17);
g.setEdge(6, 7, 19);
g.setEdge(7, 6, 19);
return g;
}
void func1()
{
cout << "func1: ---------------------" << endl;
Graph<int, int>& g = GraphEasy<int, int>();
SharedPointer< Array< Edge<int> > > sa = g.Kruskal();
int w = 0;
for(int i=0; i<sa->length(); i++)
{
w += (*sa)[i].data;
cout << (*sa)[i].b << " " << (*sa)[i].e << " " << (*sa)[i].data << endl;
}
cout << "Weight: " << w << endl;
}
void func2()
{
cout << "func2: ---------------------" << endl;
Graph<int, int>& g = GraphComplex<int, int>();
SharedPointer< Array< Edge<int> > > sa = g.Kruskal();
int w = 0;
for(int i=0; i<sa->length(); i++)
{
w += (*sa)[i].data;
cout << (*sa)[i].b << " " << (*sa)[i].e << " " << (*sa)[i].data << endl;
}
cout << "Weight: " << w << endl;
}
void func3()
{
cout << "func3: ---------------------" << endl;
Graph<int, int>& g = GraphComplex<int, int>();
SharedPointer< Array< Edge<int> > > sa = g.Kruskal(false);
int w = 0;
for(int i=0; i<sa->length(); i++)
{
w += (*sa)[i].data;
cout << (*sa)[i].b << " " << (*sa)[i].e << " " << (*sa)[i].data << endl;
}
cout << "Weight: " << w << endl;
}
int main()
{
func1();
func2();
func3();
return 0;
}输出：
func1: ---------------------
0 1 1
1 2 1
2 3 1
Weight: 3
func2: ---------------------
4 7 7
2 8 8
1 0 10
0 5 11
1 8 12
1 6 16
3 7 16
7 6 19
Weight: 99
func3: ---------------------
5 4 26
3 6 24
2 3 22
3 8 21
3 4 20
7 6 19
1 2 18
0 5 11
Weight: 161小结
- Prim 算法以顶点为核心寻找最小生成树，不够直接
- Kruskal 算法以边为核心寻找最小生成树，直观简单
- Kruskal 算法中的关键是前驱标记数组的使用
- 前驱标记数组用于判断新选择的边是否会造成回路
以上内容整理于狄泰软件学院系列课程，请大家保护原创！
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。