數據結構圖之二（最小生成樹--克魯斯卡爾算法）

【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.

順序  選擇  循環  總結