数据结构图之二（最小生成树--克鲁斯卡尔算法）

【1】克鲁斯卡尔算法

普里姆算法是以某顶点为起点，逐步找各顶点上最小权值的边来构建最小生成树。

克鲁斯卡尔算法是直接以边为目标去构建。

因为权值是在边上，直接去找最小权值的边来构建生成树也是很自然的想法，只不过构建时要考虑是否会形成环路而已。

此时我们用到了图的存储结构中的边集数组结构。

以下是边集数组结构的定义代码：

本算法所用同普里姆算法的实例，我们直接创建图的边集数组。

并对边的权值从小到大排序后如下图：

【2】克鲁斯卡尔算法及详解

克鲁斯卡尔算法及其详解：

鉴于此算法很简单，当 i=0, i=1, i=2时执行结果可以眼观，不再赘述。直接分析重点：

此算法的Find函数由边数e决定，时间复杂度为O(loge),而外面有一个for循环e次。

所以克鲁斯卡尔算法的时间复杂度为O(eloge)

对比两个算法：

克鲁斯卡尔算法主要针对边展开，边数少时效率会很高，所以对于稀疏图有优势

而普利姆算法对于稠密图，即边数非常多的情况会好些。

【3】克鲁斯卡尔算法实现

实现代码如下：

#include <iostream>
using namespace std;

#define    MAXVER  9
#define MAXEDGE 15

typedef struct Node
{
    int begin;        // 起点
    int weight;     // 权值
    int end;        // 末点
} edgeNode;

class Graph
{
private:
    edgeNode edge[MAXEDGE];
public:
    Graph()
    {
        for (int i = 0; i < MAXEDGE; ++i)
        {
            edge[i].begin = edge[i].weight = edge[i].end = 0;
        }
    }
    ~Graph()
    {}

public:
    void InsertSort()
    {
       for (int i = 0; i < MAXEDGE- 1; ++i)
       {
            if (edge[i+1].weight < edge[i].weight)
            {
                 Node temp = edge[i+1];
                 int j = i + 1;
                 do
                 {
                     edge[j] = edge[j-1];
                     --j;
                 } while(j >= 0 && edge[j].weight > temp.weight);
                                
                 edge[j+1] = temp;
            }
        }
    }

    istream & operator>>(istream &in)
    {
        int begin, value, end;
        cout << "请输入15条边的起点 终点 权值：" << endl;
        for (int i = 0; i < MAXEDGE; ++i)
        {
            in >> begin >> end >> value;
            edge[i].begin = begin;
            edge[i].weight = value;
            edge[i].end = end;
        }
        return in;
    }
    ostream & operator<<(ostream &out)
    {
        // 插入排序
        InsertSort();
        out << "输出排序边权值后信息:" << endl;
        for (int i = 0; i < MAXEDGE; ++i)
        {
            out << "edge[" << i << "] " << edge[i].begin << "  " << edge[i].weight << " " << edge[i].end << endl;
        }
        return out;
    }
    // 克鲁斯卡尔算法
    void MiniSpanTree_Kruskal()
    {
        int i = 0, n = 0, m = 0;
        int parent[MAXVER];
        for ( ; i < MAXVER; ++i)
            parent[i] = 0;
        for (i = 0; i < MAXEDGE; ++i)
        {
            n = Find(parent, edge[i].begin);
            m = Find(parent, edge[i].end);
            if (n != m)
            {
                parent[n] = m;
                cout << " " << edge[i].begin << " " << edge[i].end << " " << edge[i].weight << endl;
            }
        }
    }

    int Find(int *parent, int f)
    {
        while (parent[f] > 0)
            f = parent[f];
        return f;
    }
};

istream & operator>>(istream &in, Graph &g)
{
    g >> in;
    return in;
}

ostream & operator<<(ostream &out, Graph &g)
{
    g << out;
    return out;
}

void main()
{
    Graph myg;
    cin >> myg;
    cout << myg;
    myg.MiniSpanTree_Kruskal();
}
 // 备注：
 // 最小生成树克鲁斯卡尔算法实现
 // 整理于2013-12-04
 // 测试需要输入：
 /*
 起始   终点   权值
 0 1 10
 0 5 11
 1 2 18
 1 8 12
 1 6 16
 2 8 8
 2 3 22
 3 8 21
 3 6 24
 3 7 16
 3 4 20
 4 7 7
 4 5 26
 5 6 17
 6 7 19
  */

Good  Good  Study, Day  Day  Up.

顺序  选择  循环  总结