最小生成数kruskal算法和prim算法

定义

连通图：在无向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该无向图为连通图。

强连通图：在有向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该有向图为强连通图。

连通网：在连通图中，若图的边具有一定的意义，每一条边都对应着一个数，称为权；权代表着连接连个顶点的代价，称这种连通图叫做连通网。

生成树：一个连通图的生成树是指一个连通子图，它含有图中全部n个顶点，但只有足以构成一棵树的n-1条边。一颗有n个顶点的生成树有且仅有n-1条边，如果生成树中再添加一条边，则必定成环。

最小生成树：在连通网的所有生成树中，所有边的代价和最小的生成树，称为最小生成树。 

kruskal算法

此算法可以称为“加边法”，初始最小生成树边数为0，每迭代一次就选择一条满足条件的最小代价边，加入到最小生成树的边集合里。

1. 把图中的所有边按代价从小到大排序；

2. 把图中的n个顶点看成独立的n棵树组成的森林；

3. 按权值从小到大选择边，所选的边连接的两个顶点ui,viui,vi,应属于两颗不同的树，则成为最小生成树的一条边，并将这两颗树合并作为一颗树。

4. 重复(3),直到所有顶点都在一颗树内或者有n-1条边为止。

prim算法

此算法可以称为“加点法”，每次迭代选择代价最小的边对应的点，加入到最小生成树中。算法从某一个顶点s开始，逐渐长大覆盖整个连通网的所有顶点。

1. 图的所有顶点集合为VV；初始令集合u={s},v=V−uu={s},v=V−u;

2. 在两个集合u,vu,v能够组成的边中，选择一条代价最小的边(u0,v0)(u0,v0)，加入到最小生成树中，并把v0v0并入到集合u中。

3. 重复上述步骤，直到最小生成树有n-1条边或者n个顶点为止。

kruskal算法：

#include <iostream>
#include <list>
#include <vector>
#include <algorithm>

const int   INFINITE  = 0x7FFFFFFF;
const int   VERTEX    = 6;
const char  szVertex[] = { 'A', 'B', 'C', 'D', 'E', 'F' };

struct stEdge
{
    int u;
    int v;
    int weight;

    stEdge(int iu, int iv, int iweight):u(iu),v(iv),weight(iweight) {}
    
    friend bool operator<(const stEdge &a, const stEdge &b) { return a.weight < b.weight; }
};

void createGraph(int (*g)[VERTEX])
{
    for (int i = 0; i < VERTEX; i++)
    {
        for (int j = 0; j < VERTEX; j++)
        {
            g[i][j] = INFINITE;
        }
    }
    g[0][1] = 6; g[0][2] = 1; g[0][3] = 5;
    g[1][0] = 6; g[1][2] = 5; g[1][4] = 3;
    g[2][0] = 1; g[2][1] = 5; g[2][3] = 5; g[2][4] = 6; g[2][5] = 4;
    g[3][0] = 5; g[3][2] = 5; g[3][5] = 2;
    g[4][1] = 3; g[4][2] = 6; g[4][5] = 6;
    g[5][2] = 4; g[5][3] = 2; g[5][4] = 6;
}

void initEdges(std::vector<stEdge> &edges, const int (*g)[VERTEX])
{
    for (int i = 0; i < VERTEX; ++i)
    {
        for (int j = i+1; j < VERTEX; ++j)
        {
            edges.push_back(stEdge(i,j,g[i][j]));
        }
    }
    std::sort(edges.begin(), edges.end(), std::less<stEdge>());
}

bool notSameTree(int u, int v, std::vector<std::list<int> > &trees)
{
    int uindex = -1, vindex = -1;

    for (int i = 0; i < VERTEX; ++i)
    {
        if (std::find(trees[i].begin(), trees[i].end(), u) != trees[i].end())
        {
            uindex = i;
        }
        if (std::find(trees[i].begin(), trees[i].end(), v) != trees[i].end())
        {
            vindex = i;
        }
    }

    if (uindex != vindex)
    {
        trees[uindex].splice(trees[uindex].end(), trees[vindex]);
        return true;
    }

    return false;
}

void kruskal(const int (*g)[VERTEX])
{
    std::vector<stEdge> edges;
    initEdges(edges, g);

    std::vector<std::list<int> > trees(VERTEX);
    for (int i = 0; i < VERTEX; ++i)
    {
        trees[i].push_back(i);
    }

    for (auto e : edges)
    {
        if (notSameTree(e.u, e.v, trees))
        {
            std::cout << szVertex[e.u] << "---" << szVertex[e.v] << std::endl;
        }
    }
}

int main()
{
    int g[VERTEX][VERTEX] = {0};

    createGraph(g);

    kruskal(g);

    return 0;
}

prim算法：

#include <iostream>
#include <list>
#include <vector>
#include <algorithm>

const int   INFINITE  = 0x7FFFFFFF;
const int   VERTEX    = 6;
const char  szVertex[] = { 'A', 'B', 'C', 'D', 'E', 'F' };


struct stEdge
{
    int index;
    int weight;
};

void createGraph(int (*g)[VERTEX])
{
    for (int i = 0; i < VERTEX; i++)
    {
        for (int j = 0; j < VERTEX; j++)
        {
            g[i][j] = INFINITE;
        }
    }
    g[0][1] = 6; g[0][2] = 1; g[0][3] = 5;
    g[1][0] = 6; g[1][2] = 5; g[1][4] = 3;
    g[2][0] = 1; g[2][1] = 5; g[2][3] = 5; g[2][4] = 6; g[2][5] = 4;
    g[3][0] = 5; g[3][2] = 5; g[3][5] = 2;
    g[4][1] = 3; g[4][2] = 6; g[4][5] = 6;
    g[5][2] = 4; g[5][3] = 2; g[5][4] = 6;
}

int minIndex(const stEdge *weightArr, int len)
{
    int min = INFINITE;
    int idx = -1;

    for (int i = 0; i < len; ++i)
    {
        if (weightArr[i].weight != 0 && min > weightArr[i].weight)
        {
            min = weightArr[i].weight;
            idx = i;
        }
    }

    return idx;
}

void prim(const int (*g)[VERTEX], int index)
{
    stEdge weightArr[VERTEX];

    weightArr[index].weight = 0;
    weightArr[index].index = index;
    for (int i = 0; i < VERTEX; ++i)
    {
        if (i != index)
        {
            weightArr[i].index = index;
            weightArr[i].weight = g[index][i];
        }
    }

    for (int i = 1; i < VERTEX; ++i)
    {
        int nextIndex = minIndex(weightArr, VERTEX);
        if (nextIndex != -1)
        {
            std::cout << szVertex[weightArr[nextIndex].index] << "---" << szVertex[nextIndex] << std::endl;

            weightArr[nextIndex].weight = 0;
            weightArr[nextIndex].index = nextIndex;
            for (int j = 0; j < VERTEX; ++j)
            {
                if (weightArr[j].weight != 0 && g[nextIndex][j] < weightArr[j].weight)
                {
                    weightArr[j].index = nextIndex;
                    weightArr[j].weight = g[nextIndex][j];
                }
            }
        }
    }
}

int main()
{
    int g[VERTEX][VERTEX] = {0};

    createGraph(g);

    prim(g, 0);

    return 0;
}

转载自：https://blog.csdn.net/luoshixian099/article/details/51908175