数据结构笔记[1] Prim算法

Prim算法

Prim算法用于求解连通图中最小生成树问题。即在一个n个顶点的连通图中找出n-1条边，形成一棵树并使所有边的权值之和最小。

Prim算法的核心是将顶点集分类，分为加入生成树的点（记为集合A）和剩余的点（记为集合B）。在迭代的过程中，不断将B中到A权值最小的一点加入A中（即遍历B中所有点，对每一点遍历其到A中所有点的权值，挑权值最小的那一点加入A），直至全部顶点加入集合A

以下图为例：

其生成过程为：

Prim算法的实现

在Prim算法中，关键在于两个数组，adjvex、lowcost。刚开始学看到这两个数组有点蒙，所以自己整理了下思路，希望说的还明白，如有漏洞还请多多指教。

这两个数组的长度认为是顶点的数量就好。将它们与顶点的下标合起来看，如下图所示（n=9）

重点来了：
adjvex存的是B集合（生成树之外）中的点到A集合（生成树）最近（权值最小）的一边；
lowcost存的是B集合中的点到A集合最近的距离；
将某一点的lowcost置0的含义为：该点已经加入集合A中。

理解了它们的意义Prim算法的迭代过程就好懂了，它做的不外乎就是迭代找离集合A最近的点。以上图为例解释下它的过程：

1. 初始化，这里将0点放入生成树（即0点的lowcost置0），将所有点的Adjvex置0（表示其它点都指向生成树中唯一的一点0，0点的adjvex其实没啥意义）lowcost为各点到0点的权值。
2. 遍历表，在lowcost不为0的点中找出lowcost最小的那个，将其lowcost置0，即加入生成树A。
3. 更新表，对于所有lowcost不为0的点检查其到2.中新加入的点（记为p）的距离，如果lowcost比目前值小，更新lowcost，将adjvex改为p（看一下生成树外的点是否离生成树更近了，执行完之后所有点的lowcost应是到生成树最近的距离，adjvex应是到生成树中最近的一点）。
4. 重复2直到所有点都加入生成树。

以下是代码：
MatrixGraph.h

#include <iostream>
#include <fstream>
#include <iomanip>
#include <vector>
#include <assert.h>
using namespace std;

#ifndef _MATRIXGRAPH
#define _MATRIXGRAPH

const int INF { 65535 };

template <class T> 
class MGraph
{
private:
    vector<T> vexs;  // 顶点集
    vector<vector<int>> arc;  // 邻接矩阵
    int m_vexsnum, m_edgenum; // 顶点数与边数

public:
    MGraph(bool direction);  // 从输入创建图
    MGraph(const char* in_file);  // 读取文件创建图
    void Print();  // 打印邻接矩阵
    bool Save(const char* out_name);  // 保存图到二进制文件
    void Prim();  // Prim算法
};

#endif

MatrixGraph.cpp

#include "MatrixGraph.h"
using namespace std;
#define _INPUT 0  // 为1，输入图；为0，读取图

template <class T>
MGraph<T>::MGraph(bool direction)
{
    cout << "Please input the number of vertexs:";
    cin >> m_vexsnum;

    vexs.resize(m_vexsnum);
    arc.resize(m_vexsnum);
    for (register int i = 0; i < m_vexsnum; i++) {
        arc[i].resize(m_vexsnum);
    }

    for(register size_t i = 0; i < m_vexsnum; i++)
    {
        for(register size_t j = 0; j < m_vexsnum; j++)
        {
            arc[i][j] = (i == j) ? 0 : INF;
        }
    }

    cout << "Please input the number of edges:";
    cin >> m_edgenum;
    // cout << "Please input vertexs:" << endl;
    for(register size_t i = 0; i < m_vexsnum; i++)
    {
        // cin >> vexs[i];
        vexs[i] = i;
    }
    cout << "Please input [in out weight] of edges:" << endl;
    for(register size_t i = 0; i < m_edgenum; i++)
    {
        int ti{ 0 }, tj{ 0 }, temp{ 0 };
        cin >> ti;
        cin >> tj;
        cin >> temp;
        arc[ti][tj] = temp;
        if (!direction) { arc[tj][ti] = temp; }
    }

    visited = nullptr;
}

template<class T>
MGraph<T>::MGraph(const char* in_file)
{
    ifstream ifile(in_file, ios::binary);
    assert(ifile.is_open());

    ifile.read((char*)&m_vexsnum, sizeof(m_vexsnum));
    ifile.read((char*)&m_edgenum, sizeof(m_edgenum));
    vexs.resize(m_vexsnum);
    arc.resize(m_vexsnum);
    for (register int i = 0; i < m_vexsnum; i++) {
        arc[i].resize(m_vexsnum);
    }

    for (register int i = 0; i < m_vexsnum; i++) {
        ifile.read((char*)&vexs[i], sizeof(T));
    }
    for (int i = 0; i < m_vexsnum; i++)
    {
        for (int j = 0; j < m_vexsnum; j++)
        {
            ifile.read((char*)&arc[i][j], sizeof(int));
        }
        cout << endl;
    }
    ifile.close();

    visited = nullptr;
}

template<class T>
void MGraph<T>::Print()
{
    cout << "Elements:" << endl;
    for (register int i = 0; i < m_vexsnum; i++) {
        cout << vexs[i] << " ";
    }
    cout << endl << "Edges:" << endl;
    for (register int i = 0; i < m_vexsnum; i++)
    {
        for (register int j = 0; j < m_vexsnum; j++)
        {
            cout << setw(7) << arc[i][j] << " ";

        }
        cout << endl;
    }
}

template<class T>
bool MGraph<T>::Save(const char* out_name)
{
    ofstream ofile(out_name, ios::binary);
    assert(ofile.is_open());
    
    ofile.write((char*)&m_vexsnum, sizeof(m_vexsnum));
    ofile.write((char*)&m_edgenum, sizeof(m_edgenum));
    for (register int i = 0; i < m_vexsnum; i++) {
        ofile.write((char*)&vexs[i], sizeof(T));
    }
    cout << endl;
    for (int i = 0; i < m_vexsnum; i++)
    {
        for (int j = 0; j < m_vexsnum; j++)
        {
            cout << setw(3) << arc[i][j] << " ";
            ofile.write((char*)&arc[i][j], sizeof(int));
        }
        cout << endl;
    }
    ofile.close();
    return true;
}

template<class T>
void MGraph<T>::Prim()
{
    typedef struct {
        int adjvex;
        int lowcost;
    }close_node;
    vector<close_node> close(m_vexsnum);
    // 初始化，起始点为0，存储其余点到0点的距离
    close[0].lowcost = 0;
    for (int i = 0; i < m_vexsnum; i++) {
        close[i].adjvex = 0;
        close[i].lowcost = arc[0][i];
    }
    for (int i = 0; i < m_vexsnum; i++) {
        // 查找生成树外的点到生成树中点的最近距离
        int k{ 0 }, min{ INF };
        for (int j = 0; j < m_vexsnum; j++) {
            if (close[j].lowcost > 0 && close[j].lowcost < min) {
                k = j;
                min = close[j].lowcost;
            }
        }

        // 输出信息
        cout << "(" << close[k].adjvex << "," << k << ")" << endl;

        // 将距树中点距离最小的点加入生成树
        close[k].lowcost = 0;

        // 更新列表，看看那些点距离新加入的k比之前近
        for (int j = 0; j < m_vexsnum; j++) {
            if (close[j].lowcost > 0 && arc[k][j] < close[j].lowcost) {
                close[j].adjvex = k;
                close[j].lowcost = arc[k][j];
            }
        }
        // 更新之后，close之中永远存的是各点到生成树的最小距离和连接的点
    }
}

int main(void)
{
#if _INPUT
    MGraph<int> g(false);
    g.Print();
    g.Save("Prim_test.dat");
#endif
    MGraph<int> g1("Prim_test.dat");
    g1.Print();
    
    cout << "\nPrim:" << endl;
    g1.Prim();
    return 0;
}

将本文开始的图输入程序，结果如下：

与示例的结果相同。