图论---cruskal算法（未完成）

由于cruskal算法的执行过程中需要合并，而致使实现较复杂，下面的算法基本上已有形状，还剩几个步骤，先留着，说不定我这个实现不是很好，遇到相关问题了再具体研究

/*-------------------------------------------------------------------
* Purpose:
*         使用cruskal算法求最小生成树
*         使用图为算法导论第二版p344 图23-1
* Time:
*         2012年3月19日 20:58:28
* Author:
*         张彦升
--------------------------------------------------------------------*/
#include <iostream>
#include <set>
#include <vector>

using namespace std;

#define V 9    /*点的个数*/

const int inf = 0x3f3f3f3f;
int vis[V];
int lowc[V];    /*最低代价*/

/**
 * kruskal算法要对所有的边进行排序，所以需要一个边表
 * 由边表可以得到边的两个顶点的位置，及其权重
 */
struct EdgeTable 
{
    int u;
    int v;
    int weight;

    EdgeTable(int t_u,int t_v,int t_weight)
        :u(u),
        v(t_v),
        weight(t_weight)
    {
        return;
    }
};
bool operator <(const EdgeTable& left,const EdgeTable& right) const
{
    if (left.weight < right.weight)
    {
        return true;
    }
    return false;
}
struct TreeSet 
{
    typedef set<int> SetInt;
    SetInt vetexs;

    int get_identifer()
    {
        return vetexs.front();
    }
    /**
     * 若在其中则返回真，若没有则返回假
     */
    bool find_vetex(int v)
    {
        SetInt::iterator iter = vetexs.find(v);
        if (iter != vetexs.end())
        {
            return true;
        }
        return false;
    }
};
typedef vector<TreeSet> TreeSets;
/**
 * 
 */
int make_set(int n,TreeSets& tree_sets)
{
    for (int i = 0;i < n;i++)
    {
        tree_sets.push_back(i);
    }
    return 0;
}
typedef set<EdgeTable,greater<EdgeTable> > Edges;
/**
 * 初始化边表，由递增顺序排列
 */
int init_edge(int cost[][V],int n,Edges &edges)
{
    for (int i = 0;i < n;i ++)
    {
        for (int j = 0;j < n;j ++)
        {
            int c = cost[i][j];
            if (c != inf)
            {
                edges.insert(EdgeTable(i,j,c));
            }
        }
    }
    
    return 0;
}
/**
 * 找到节点v所在的集合
 */
int find_set(TreeSets tree_sets,int u)
{
    TreeSets::iterator iter_tree_set = tree_sets.begin();
    for (;iter_tree_set != tree_sets.end();++iter_tree_set)
    {
        bool b_found = iter_tree_set.find_vetex(u);
        if (b_found == true)
        {
            return iter_tree_set.get_identifer();
        }
        
    }
    
    return -1;
}
int cruskal(int cost[][V],int n)
{
    EdgeTable edges;
    TreeSets tree_sets;
    init_edge(cost,n,edges);
    make_set(n,tree_sets);
    EdgeTable::iterator iter_edge = edges.begin();
    int id_u = -1;
    int id_v = -1;

    for (;iter_edge != edges.end();++iter_edge)
    {
        id_u = find_set(tree_sets,iter_edge.u);
        id_v = find_set(tree_sets,iter_edge.v);

        if (id_u == -1 || id_v == -1)
        {
            cout << "在寻找集合的时候不应该出现找不见的情况" << endl;
            return -1;
        }
        else if (id_u != id_v)
        {
        }
        
        
    }
    
    return 0;
}

int main()
{
    int cost[V][V] = {
       /* a b c d e f g h i*/
        {inf,4,inf,inf,inf,inf,inf,8,inf},
        {4,inf,8,inf,inf,inf,inf,11,inf},
        {inf,8,inf,7,inf,4,inf,8,2},
        {inf,4,7,inf,9,14,inf,8,inf},
        {inf,4,inf,9,inf,10,inf,8,inf},
        {inf,inf,4,14,10,inf,2,8,inf},
        {inf,inf,inf,inf,inf,2,inf,1,6},
        {8,11,inf,inf,inf,inf,1,inf,7},
        {inf,inf,2,inf,inf,inf,6,7,inf},
    };
    int res = cruskal(cost,V);
    cout << res << endl;

    return 0;
}