【算法和数据结构】图（三）最小生成树之Kruskal算法（C++实现）

最新推荐文章于 2024-08-03 15:53:55 发布
最新推荐文章于 2024-08-03 15:53:55 发布
阅读量2.4k 收藏 8
点赞数 2
分类专栏： 编程语言 文章标签： kruskal prim 图-最小生成树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28869927/article/details/60474670
版权

      在前面两节图和图的最小生成树之Prim算法的基础上，这里给出另外一种求解MST（最小生成树）的算法—–Kruskal算法。

       Kruskal算法可以概括为：

  1. 取出连通无向图G的所有边。
  2. 从第一步形成的边集合中选取权值最小的边，加入最小生成树边集合T中。
  3. 求出第二步中选出边的两端顶点，判断他们所在顶点集的关系以确认是否存在回路。若不存在回路，则确认将此最小边加入T中，若存在回路，则丢弃。

       同Prim算法，我们用下面这一连通无向图作为示例：
这里写图片描述

       下面给出实现代码以及测试代码：（在图以及Prim算法的基础上增加而来，若读者觉得阅读有困难，可参看前两节文章）

#include<iostream>
#include<cstdlib>
#include<vector>
using namespace std;

/*节点类*/
class Node
{
public:
    Node(char identifier = 0);

    char m_identifier;       //顶点编号
    bool m_isVisited;        //顶点访问标志位：true表示已经被访问
};
Node::Node(char identifier)
{
    m_identifier = identifier;
    m_isVisited = false;
}


/*边类，用于辅助实现生成最小生成树*/
class Edge
{
public:
    Edge(int NodeIndexA = 0, int NodeIndexB = 0, int WeightValue = 0);

    int m_NodeIndexA, m_NodeIndexB;    //边的两端点（索引），这里以无向图为例
    int m_weightValue;                 //边的权值
    bool m_selected;                   //选择标志位，true表示已被选择
};
Edge::Edge(int NodeIndexA, int NodeIndexB, int WeightValue)
{
    m_NodeIndexA = NodeIndexA;
    m_NodeIndexB = NodeIndexB;
    m_weightValue = WeightValue;
    m_selected = false;      //初始时未被选择
}

/*图类*/
class Graph
{
public:
    Graph(int capacity);
    ~Graph();

    int getGraphSize();            //获取当前图的大小
    void resetNode();              //重置所有顶点的访问标志位为false，未访问
    bool addNode(Node *pNode);     //添加新顶点
    bool addEdgeForUndirectedGraph(int row, int col, int val = 1); //添加边以构造无向图，val表示权值，默认权值1
    bool addEdgeForDirectedGraph(int row, int col, int val = 1);   //添加边以构造有向图，val表示权值，默认权值1
    void printMatrix();   //打印邻接矩阵

    void depthFirstTraverse(int nodeIndex);   //深度优先遍历，指定第一个点
    void widthFirstTraverse(int nodeIndex);   //广度优先遍历，指定第一个点

    void MSTPrim(int nodeIndex);        //Prim算法求最小生成树，指定第一个点
    void MSTKruskal();     //Kruskal算法求最小生成树，指定第一个点

private:
    bool getValueOfEdge(int row, int col, int &val);  //获取边权值
    void widthFirstTraverseImplement(vector<int> preVec);  //利用vector实现广度优先遍历

    int getMinEdge(vector<Edge> edgeVec);  //最小生成树算法辅助函数，用于在边集中选择权值最小的边
    bool isInSet(vector<int> nodeSet, int target);  //Kruskal辅助函数，用于判断指定顶点是否在给定点集中
    void mergeNodeSets(vector<int> &nodeSetA, vector<int> nodeSetB);  //Kruscal辅助函数，用于合并两个点集

    int m_iCapacity;     //图容量，即申请的数组空间最多可容纳的顶点个数
    int m_iNodeCount;    //图的现有顶点个数
    Node *m_pNodeArray;  //存放顶点的数组
    int *m_pMatrix;      //为了方便，用一维数组存放邻接矩阵

    Edge *m_pEgde;       //边指针，存储最小生成树的边
};
Graph::Graph(int capacity)
{
    m_iCapacity = capacity;
    m_iNodeCount = 0;

    m_pNodeArray = new Node[m_iCapacity];
    m_pMatrix = new int[m_iCapacity*m_iCapacity];

    for (int i = 0;i < m_iCapacity*m_iCapacity;i++)  //初始化邻接矩阵
    {
        m_pMatrix[i] = 0;
    }

    m_pEgde = new Edge[m_iCapacity - 1];    //最小生成树节点和边数量关系
}
Graph::~Graph()
{
    delete []m_pNodeArray;
    delete []m_pMatrix;
    delete []m_pEgde;
}

int Graph::getGraphSize()
{
    return m_iNodeCount;
}
void Graph::resetNode()
{
    for (int i = 0;i < m_iNodeCount;i++)
    {
        m_pNodeArray[i].m_isVisited = false;
    }
}
bool Graph::addNode(Node *pNode)
{
    if (pNode == NULL)
        return false;
    m_pNodeArray[m_iNodeCount].m_identifier = pNode->m_identifier;
    m_iNodeCount++;
    return true;
}
bool Graph::addEdgeForUndirectedGraph(int row, int col, int val)
{
    if (row < 0 || row >= m_iCapacity)
        return false;
    if (col < 0 || col >= m_iCapacity)
        return false;
    m_pMatrix[row*m_iCapacity + col] = val;
    m_pMatrix[col*m_iCapacity + row] = val;
    return true;
}
bool Graph::addEdgeForDirectedGraph(int row, int col, int val)
{
    if (row < 0 || row >= m_iCapacity)
        return false;
    if (col < 0 || col >= m_iCapacity)
        return false;
    m_pMatrix[row*m_iCapacity + col] = val;
    return true;
}
void Graph::printMatrix()
{
    for (int i = 0;i < m_iCapacity;i++)
    {
        for (int k = 0;k < m_iCapacity;k++)
            cout << m_pMatrix[i*m_iCapacity + k] << " ";
        cout << endl;
    }
}

void Graph::depthFirstTraverse(int nodeIndex)
{
    int value = 0;

    //访问第一个顶点
    cout << m_pNodeArray[nodeIndex].m_identifier << " ";
    m_pNodeArray[nodeIndex].m_isVisited = true;

    //访问其他顶点
    for (int i = 0;i < m_iCapacity;i++)
    {
        getValueOfEdge(nodeIndex, i, value);
        if (value != 0)   //当前顶点与指定顶点连通
        {
            if (m_pNodeArray[i].m_isVisited == true)  //当前顶点已被访问
                continue;
            else           //当前顶点没有被访问，则递归
            {
                depthFirstTraverse(i);
            }
        }
        else       //没有与指定顶点连通
        {
            continue;
        }
    }
}
void Graph::widthFirstTraverse(int nodeIndex)
{
    //访问第一个顶点
    cout << m_pNodeArray[nodeIndex].m_identifier << " ";
    m_pNodeArray[nodeIndex].m_isVisited = true;

    vector<int> curVec;
    curVec.push_back(nodeIndex);      //将第一个顶点存入一个数组
    widthFirstTraverseImplement(curVec);
}
void Graph::widthFirstTraverseImplement(vector<int> preVec)
{
    int value = 0;
    vector<int> curVec;    //定义数组保存当前层的顶点
    for (int j = 0;j < (int)preVec.size();j++)  //依次访问传入数组中的每个顶点
    {
        for (int i = 0;i < m_iCapacity;i++)  //传入的数组中的顶点是否与其他顶点连接
        {
            getValueOfEdge(preVec[j], i, value);
            if (value != 0)   //连通
            {
                if (m_pNodeArray[i].m_isVisited==true)  //已经被访问
                {
                    continue;
                }
                else   //没有被访问则访问
                {
                    cout << m_pNodeArray[i].m_identifier << " ";
                    m_pNodeArray[i].m_isVisited = true;

                    //保存当前点到数组
                    curVec.push_back(i);
                }
            }
        }
    }

    if (curVec.size()==0)   //本层次无被访问的点，则终止
    {
        return;
    }
    else
    {
        widthFirstTraverseImplement(curVec);
    }
}
bool Graph::getValueOfEdge(int row, int col, int &val)
{
    if (row < 0 || row >= m_iCapacity)
        return false;
    if (col < 0 || col >= m_iCapacity)
        return false;
    val = m_pMatrix[row*m_iCapacity + col];
    return true;
}

void Graph::MSTPrim(int nodeIndex)
{
    int value = 0;          //存储当前边的权值
    int edgeCount = 0;      //已选出的边数量，用以判断算法终结
    vector<int> nodeVec;    //存储点（索引）集的数组
    vector<Edge> edgeVec;   //存储边的数组

    cout << m_pNodeArray[nodeIndex].m_identifier << endl;

    nodeVec.push_back(nodeIndex);
    m_pNodeArray[nodeIndex].m_isVisited = true;

    while (edgeCount < m_iCapacity - 1)
    {
        int temp = nodeVec.back();           //将当前顶点索引复制给temp
        for (int i = 0;i < m_iCapacity;i++)  //循环判断每一个顶点与当前顶点连接情况
        {
            getValueOfEdge(temp, i, value);
            if (value != 0)  //连通
            {
                if (m_pNodeArray[i].m_isVisited == true) //已经被访问
                    continue;
                else //未被访问,则将边放入被选边集合
                {
                    Edge edge(temp, i, value);
                    edgeVec.push_back(edge);
                }
            }
        }
        /*选择最小边*/
        int edgeIndex = getMinEdge(edgeVec);
        if (edgeIndex == -1)
        {
            cout << "获取最小边失败，请重置后再试！" << endl;
            break;
        }

        edgeVec[edgeIndex].m_selected = true;   //设置选择标志位为true，已被选择

        cout << edgeVec[edgeIndex].m_NodeIndexA << "---" << edgeVec[edgeIndex].m_NodeIndexB<<" ";
        cout << edgeVec[edgeIndex].m_weightValue << endl;

        m_pEgde[edgeCount] = edgeVec[edgeIndex];
        edgeCount++;

        /*寻找当前选择的最小边相连的下一个顶点*/
        int nextNodeIndex = edgeVec[edgeIndex].m_NodeIndexB;
        nodeVec.push_back(nextNodeIndex);
        m_pNodeArray[nextNodeIndex].m_isVisited = true;

        cout << m_pNodeArray[nextNodeIndex].m_identifier << endl;
    }
    cout << "最小生成树计算完毕，如上所示！";
}
void Graph::MSTKruskal()
{
    int value = 0;          //存储当前边的权值
    int edgeCount = 0;      //已选出的边数量

    /*存放节点集合的数组,不同于Prim，Kruskal算法过程中可能出现多个点集*/
    vector<vector<int>> nodeSets;

    /*取出所有边*/
    vector<Edge> edgeVec;
    for (int i = 0;i < m_iCapacity;i++)     //去邻接矩阵的右上角的三角部分，不含对角线。无向图邻接矩阵对称
    {
        for (int k = i + 1;k < m_iCapacity;k++)
        {
            getValueOfEdge(i, k, value);
            if (value != 0)
            {
                Edge edge(i, k, value);
                edgeVec.push_back(edge);
            }
        }
    }

    /*循环寻找最小生成树的边*/
    while (edgeCount < m_iCapacity - 1)
    {
        int minEdgeIndex = getMinEdge(edgeVec);
        edgeVec[minEdgeIndex].m_selected = true;    //选出最小边，并标记为已选

        int nodeAIndex = edgeVec[minEdgeIndex].m_NodeIndexA;
        int nodeBIndex = edgeVec[minEdgeIndex].m_NodeIndexB;    //找出最小边两端顶点

        bool nodeAIsInSet = false;    //标记某个顶点是否在指定点集中
        bool nodeBIsInSet = false;    
        int nodeAInSetLabel = -1;     //某个顶点所在点集的索引
        int nodeBInSetLabel = -1;


        for (int i = 0;i < (int)nodeSets.size();i++)   //寻找A顶点所在点集
        {
            nodeAIsInSet = isInSet(nodeSets[i], nodeAIndex);
            if (nodeAIsInSet)
            {
                nodeAInSetLabel = i;       //保存当前点集索引
            }
        }
        for (int i = 0;i < (int)nodeSets.size();i++)   //寻找B顶点所在点集
        {
            nodeBIsInSet = isInSet(nodeSets[i], nodeBIndex);
            if (nodeBIsInSet)
            {
                nodeBInSetLabel = i;       //保存当前点集索引
            }
        }

        /*根据结果做相应处理*/
        if (nodeAInSetLabel == -1 && nodeBInSetLabel == -1)  //两顶点均不在已有点集中
        {
            //建立新的点集
            vector<int> vec;
            vec.push_back(nodeAIndex);
            vec.push_back(nodeBIndex);
            nodeSets.push_back(vec);
        }
        else if (nodeAInSetLabel == -1 && nodeBInSetLabel != -1)  //某顶点在已有点集中
        {
            //将另外一个节点加入已有点集
            nodeSets[nodeBInSetLabel].push_back(nodeAIndex);
        }
        else if (nodeAInSetLabel != -1 && nodeBInSetLabel == -1)
        {
            nodeSets[nodeAInSetLabel].push_back(nodeBIndex);
        }
        else if (nodeAInSetLabel != -1 && nodeBInSetLabel != -1 && nodeAInSetLabel != nodeBInSetLabel)  //两个顶点在不同的点集中
        {
            //合并两个集合，到前一参数点集，并将顶点从第二个参数点集删除
            mergeNodeSets(nodeSets[nodeAInSetLabel], nodeSets[nodeBInSetLabel]);
            for (int k = nodeBInSetLabel;k < (int)nodeSets.size()-1;k++)
            {
                nodeSets[k] = nodeSets[k + 1];
            }
        }
        else if (nodeAInSetLabel != -1 && nodeBInSetLabel != -1 && nodeAInSetLabel == nodeBInSetLabel)  //两个顶点在同一点集
        {
            //存在回路，放弃当前边
            continue;
        }

        m_pEgde[edgeCount] = edgeVec[minEdgeIndex];
        edgeCount++;

        cout << edgeVec[minEdgeIndex].m_NodeIndexA << "---" << edgeVec[minEdgeIndex].m_NodeIndexB << " ";
        cout << edgeVec[minEdgeIndex].m_weightValue << endl;
    }
}
int Graph::getMinEdge(vector<Edge> edgeVec)
{
    int minWeight = 0;   //用于辅助选择最小权值边
    int edgeIndex = 0;   //用于存储最小边索引
    int i = 0;

    /*找出第一条未被选择的边*/
    for (;i < (int)edgeVec.size();i++)
    {
        if (edgeVec[i].m_selected == false)  //当前边未被选择
        {
            minWeight = edgeVec[i].m_weightValue;
            edgeIndex = i;
            break;
        }
    }

    if (minWeight == 0)   //边集所有边被访问
    {
        return -1;
    }

    for (;i < (int)edgeVec.size();i++)
    {
        if (edgeVec[i].m_selected == true)
            continue;
        else
        {
            if (minWeight > edgeVec[i].m_weightValue)
            {
                minWeight = edgeVec[i].m_weightValue;
                edgeIndex = i;
            }
        }
    }

    return edgeIndex;
}
bool Graph::isInSet(vector<int> nodeSet, int target)
{
    for (int i = 0;i < (int)nodeSet.size();i++)
    {
        if (nodeSet[i] == target)
            return true;
    }
    return false;
}
void Graph::mergeNodeSets(vector<int> &nodeSetA, vector<int> nodeSetB)
{
    for (int i = 0;i < (int)nodeSetB.size();i++)
    {
        nodeSetA.push_back(nodeSetB[i]);
    }
}

int main()
{
    Graph *pGraph = new Graph(6);

    cout << "初始化顶点中……" << endl;
    Node *pNodeA = new Node('A');
    Node *pNodeB = new Node('B');
    Node *pNodeC = new Node('C');
    Node *pNodeD = new Node('D');
    Node *pNodeE = new Node('E');
    Node *pNodeF = new Node('F');

    cout << "添加顶点至图中……" << endl;
    pGraph->addNode(pNodeA);
    pGraph->addNode(pNodeB);
    pGraph->addNode(pNodeC);
    pGraph->addNode(pNodeD);
    pGraph->addNode(pNodeE);
    pGraph->addNode(pNodeF);

    pGraph->addEdgeForUndirectedGraph(0, 1, 6);
    pGraph->addEdgeForUndirectedGraph(0, 4, 5);
    pGraph->addEdgeForUndirectedGraph(0, 5, 1);
    pGraph->addEdgeForUndirectedGraph(1, 5, 2);
    pGraph->addEdgeForUndirectedGraph(1, 2, 3);
    pGraph->addEdgeForUndirectedGraph(2, 5, 8);
    pGraph->addEdgeForUndirectedGraph(2, 3, 7);
    pGraph->addEdgeForUndirectedGraph(3, 5, 4);
    pGraph->addEdgeForUndirectedGraph(3, 4, 2);
    pGraph->addEdgeForUndirectedGraph(4, 5, 9);


    cout << "邻接矩阵如下:" << endl;
    pGraph->printMatrix();
    cout << endl << endl;

    cout << "深度优先遍历：" << endl;
    pGraph->depthFirstTraverse(0);
    cout << endl << endl;

    pGraph->resetNode();

    cout << "广度优先遍历：" << endl;
    pGraph->widthFirstTraverse(0);
    cout << endl << endl;

    pGraph->resetNode();

    cout << "最小生成树为：" << endl;
    pGraph->MSTKruskal();
    cout << endl;

    system("pause");
}

       测试结果如下：
这里写图片描述

       在文章开始对Kruskal算法的描述中，涉及到循环的每一次都要寻找最小边的问题。我们可以换一种思路，作如下描述：

  1. 对G的边以飞降序权重排序。
  2. 对于排序表中的每条边，如果现在把它加入T不会形成回路，则将其加入T集合中，否则丢弃。

      有兴趣的读者可以自己用这一种算法描述来改进Krukal算法，这样就不需要每进行一次循环就需要调用getMinEdge()函数，可以减少算法时间开销。这样一来，若G含有m条边，则其算法时间复杂度为O（m * log m）。

        点击这里下载完整源码。

Beb1997
关注
专栏目录
C++使用Kruskal和Prim算法实现最小生成树
12-31
很久以前就学过最小生成树之Kruskal和Prim算法，这两个算法很容易理解，但实现起来并不那么容易。最近学习了并查集算法，得知并查集可以用于实现上述两个算法后，我自己动手实现了最小生成树算法。 宏观上讲，...
Kruskal算法求最小生成树
MJ_Lee的博客
03-21 1842
Kruskal算法简单实现如下： void Kruskal(V,T){ T=V; //初始化树T,仅含顶点 numS=n; //连通分量数 while(numS>1){ //连通分量数>1 //从E中取出权值最小的边(v,u) if(v和u属于不同连通分量){ T=T∪{(u,v)}; //将边加入树中 numS--; //连...
最小生成树——克鲁斯卡尔算法(Kruskal算法)
不积极分子
03-30 4462
克鲁斯卡尔算法(Kruskal算法) 对于n个顶点的连通图而言，其生成的最小生成树有n-1条边，即可以保证从任一点出发可以到达任一点且不产生回路。 克鲁斯卡尔算法(Kruskal算法)：对每条边的权值进行从小到大排序，然后从小到大取权值最小的边，如取出的边会在树中产生回路则舍去，取下一条；若不会产生回路则加入到树中。 因此Kruskal算法的关键问题就是：如何判断新加入的边是否会产生回路。 判断是...
C++ 最小生成树 洛谷
最新发布
2401_86043888的博客
08-03 2111
最小生成树是个啥？其实就像杨志一行人押送生辰纲。抛开最后生辰纲被抢的结局不谈，杨志他们需要到好几个地方，每个地方都需要花点过路费给梁山好汉们打点。比如下面就是一张城市地图：其中每两个图之间的路径长就是要给梁山好汉们打点的银子数。比如。那么问题来了，。（不信？画几个图试试）众所周知，。（还是不信？画图......）所以，**我们就管这棵各边权值（费用）和叫“最小生成树”**了。那这个最小生成树到底怎么搞呢？我们伟大的先哲发明了两种算法：一种叫，另一种叫。
c++ kruskal算法求最小生成树
2301_76180325的博客
06-12 350
Kruskal算法是一种用来求解最小生成树的贪心算法，它的基本思想是按照边的权值从小到大的顺序将边加入到图中，但必须保证加入的边不会与已加入的边形成环，直到图中所有节点都被连接为止。由 V 中的全部 n 个顶点和 E 中 n−1 条边构成的无向连通子图被称为 G 的一棵生成树，其中边的权值之和最小的生成树被称为无向图 G 的最小生成树。给定一张边带权的无向图 G=(V,E)，其中 V 表示图中点的集合，EE 表示图中边的集合，n=|V|，m=|E|。求最小生成树的树边权重之和，如果最小生成树不存在则输出。
图之最小生成树Kruskal方法c++实现
baidu_40487407的博客
12-07 329
克鲁斯卡尔算法 克鲁斯卡尔算法的基本思想是以边为主导地位，始终选择当前可用（所选的边不能构成回路）的最小权植边。所以Kruskal算法的第一步是给所有的边按照从小到大的顺序排序。这一步可以直接使用库函数qsort或者sort。接下来从小到大依次考察每一条边（u，v）。 具体实现过程如下： <1>　设一个有n个顶点的连通网络为G（V,E），最初先构造一个只有n个顶点，没有边的非连通...
【贪心法】C++实现使用Kruskal算法构建最小生成树（包括查并集操作的实现）
Mister_Yu的博客
12-22 767
Kruskal算法简介： （1）将所有边按权值从小到大排序； （2）选出权值最小的边，如果这条边的两个端点不属于同一个集合，就将这条边添加到最小生成树里面； （3）重复（2）直到选出了 节点数−1节点数-1节点数−1 条边； 如果最后选出的边数小于 节点数−1节点数-1节点数−1 ，说明该无向图不能构建出最小生成树。 查并集操作简介： 这里我们假设集合是用树来表示的，也就是每个节点都有一个父节点（根节点的父节点是自身）。 因此通过不断往上一个集合里面的点的父节点，最后都可以找到根节点，也就意味着每个集合是
最小生成树(MTS)之Kruskal数据结构与算法
12-30
最小生成树：minimum spanning tree 在连通网的所有生成树中，所有边的代价和最小的生成树，称为最小生成树。 Kruskal不是最小生成树的最有效算法，但却是学习图论必不可少的一步。 本代码旨在帮助初学图论的编程...
C++ Prim算法Kruskal算法构造可以使n个城市连接的最小生成树
06-12
（1）、实验题目：给定一个地区的n 个城市间的距离网，用Prim算法或Kruskal算法建立最小生成树，并得到的最小生成树的代价。 （2）、实验要求： 1、城市间的距离网采用的邻接矩阵表示，邻接矩阵的存储结构定义采用...
最小生成树的kruskal算法实现
04-27
实现了kruskal的算法，测试可行。
59、【图+树】最小生成树（BST）问题——Prim算法和Kruskal算法（C/C++版）
STAR GAME
05-16 1995
一、介绍 最小生成树是 设图中节点数为n，边数为m。 当存储的图为稠密图时，常用朴素Prim算法O(n2)；当存储的图为稀疏图时，常用Kruskal算法O(m log2m)。
C++算法：加权连通图的最小生成树(Kruskal)
攻城狮的博客
06-14 1346
最小生成树算法就是在众多可行的方案中选择代价最小的方法。生活中我们经常会遇到类似可以抽象成最小生成树的例子：比如你要给家中布电线，我们将每个用电器看作是顶点，那你可以从总闸布设到每一电器的电线，也可以从就近点接线。假设我们用从就近点接线，那就存在如何布线更节约的问题。这就是最小生成树可以解决的问题。用数学话来说，存在一个有n个顶点的带权连通图G。如果存在一个包含了G中所有顶点以及部分边的子图G，且子图G的各边权值和最小，并且还不形成回路。那么我们就可以称子图G是图G的最小生成树。
C/C++ 最小生成树—Kruskal算法
Carizy的博客
07-09 978
一、最小生成树 一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。 在一给定的无向图G = (V, E) 中，(u, v) 代表连接顶点 u 与顶点 v 的边，而 w(u, v) 代表此边的权重，若存在 T 为 E 的子集且为无循环图，使得 的 w(T) 最小，则此 T 为 G 的最小生成树。 最小生成树其实是最小权重生成树的简称。 二、Kruskal算法（克鲁斯卡尔算法） 构造过程 假设连通网N = (V, E)，将N中的边按权值从小到
Kruskal算法实现最小生成树（C++实现）
Curz酥的博客
02-14 4174
Kruskal算法简单讲解。
C++ Kruskal算法求最小生成树
叶子的小本本
08-01 2232
听了雨巨的课，来做个笔记。 一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有 保持图连通的最少的边。最小生成树可以用kruskal（克鲁斯卡尔）算法或prim（普里姆）算法求出。 ————百度百科 Kruskal算法简述 假设 WN=(V,{E}) 是一个含有 n 个顶点的连通网，则按照克鲁斯卡尔算法构造最小生成树的过程为：
c++实现kruskal算法（最小生成树）
orange_monkey的博客
11-30 665
#include<iostream> using namespace std; const int MAX = 15; //数组最大容量 struct Edge { int begin; int end; int weight; }; class Graph { private: int vertex_num; //顶点数 int edge_num; //边数 Edge edges[MAX]; //边集数组 char vertex[MAX]; //顶点数组 int pa
最小生成树Kruskal算法实现C++实现
pleasetojava
11-08 330
// Kruskal算法实现.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include&lt;iostream&gt; #define MAX 100 typedef int WeiType; using namespace std; // struct ...
C++最小生成树Kruskal算法
夏洛克福尔摩斯
03-15 1990
Kruskal算法是求解无向有权图的最小生成树的一种渐进时间复杂度为O（n+eloge）算法（如果用小根堆进行排序的话），它利用了贪心策略：每次寻找权值最小的边加入集合，且这个边的加入不会产生回路。详细的算法步骤分析，参照https://blog.csdn.net/mgsky1/article/details/77840286 #include&lt;iostream&gt; #include...
C++实现Kruskal与Prim最小生成树算法
本资源包含两个常用的算法实现，即Kruskal算法和Prim算法，用于在C++环境中构建最小生成树。这两种算法都是解决工程造价最小化问题的有效工具，例如在城市交通网络规划中，通过找到最低成本的连接方式来构建网络。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值