数据结构课程设计-克鲁斯卡尔算法最小生成树

     假设连通网N=（V，{E}），则令最小生成树的初始状态为只有n个顶点而无边的非连通图T=（V，{∮}），图中每个顶点自成一个连通分量。在E中选择代价最小的边，若该边依附的顶点落在T中不同的连通分量上，则将此边加入到T中，否则舍去此边而选择下一条代价最小的边。依次类推，直至T中所有顶点都在同一连通分量上为止。

（1）根据原图，构造一个只含n个顶点，边集为空的子图。若将图中各个顶点看成一棵树的根节点，则它是一个含有n棵树的森林。

（2）从网的边集 E 中选取一条权值最小的边，若该条边的两个顶点分属不同的树，则将其加入子图。也就是说，将这两个顶点分别所在的两棵树合成一棵树；反之，若该条边的两个顶点已落在同一棵树上，则不可取，而应该取下一条权值最小的边再试之

（3）依次类推，直至森林中只有一棵树，也即子图中含有 n-1条边为止。

     手动输入建立邻接矩阵：

首先输入城市数目n，建立n*n大小空矩阵。其次输入城市名称，并利用map函数使名称与数字可以相互转化。最后输入可构建线路的条数x，并输入x条边及权值填充邻接矩阵。

                                            

      寻找根结点

根节点数组中保存对应的上一节点的值。依次往上寻找，知道数组中存储值为0，此时的参数即位目前的根节点。

                                         

      克鲁斯卡尔算法输出

建立边集数组，保证起始点的数值小于终点。利用sort函数，按权值将边从小到大排列。从小到大遍历所有边，查找每条边的起始点的根节点和终点的根节点。如果不同，证明加上这条边不会产生回路，输出这条边的信息，并使节点数组中终点的上一节点为初始点。

                                   

界面：

 

代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <stdlib.h>
#include <algorithm>
#include <map>
#include <iomanip>
#include <fstream>
using namespace std;

#define max_city 100   //最大城市数

map <string,int> city_numbers;  //城市->编号

map <int,string> numbers_city;  //编号->城市

const int inf=0x3f3f3f3f;

typedef struct
{
    int maps[max_city][max_city];   //邻接矩阵
    int city_number;
    int city_way;  //城市数，线路数
} Graph ;

typedef struct
{
    int way_begin;
    int way_end;
    int way_weight;
} Ways;
//线路集

void BuildGraph1(Graph *this_graph)
{
    printf("请输入城市数（按回车键结束输入）：
");
    cin>>this_graph->city_number;

    for (int i=0;i<this_graph->city_number;i++)
    {
        for(int j=0;j<this_graph->city_number;j++)
        {
            if (i==j)
                this_graph->maps[i][j]=0;
            else
                this_graph->maps[i][j]=this_graph->maps[j][i]=inf;
        }
    }

    printf("请输入城市名称（城市名字之间用空格隔开，按回车键结束输入）：
");
    for(int i=0;i<this_graph->city_number;i++)
    {
        char name[1000];
        cin>>name;
        city_numbers[name]=i;
        numbers_city[i]=name;
    }

    printf("请输入可构架线路数（按回车键结束输入）：
");
    cin>>this_graph->city_way;

    printf("请输入每条线路两端的城市名及权值：
");
    for(int i=0;i<this_graph->city_way;i++)
    {
        char start[1000],last[1000];
        int weight;
        printf("请输入第%d条线路（城市名及权值用空格隔开，每条线路按回程键结束输入）：
",i+1);

        cin>>start>>last>>weight;
        this_graph->maps[city_numbers[start]][city_numbers[last]]=this_graph->maps[city_numbers[last]][city_numbers[start]]=weight;
    }

}
//手动输入信息

bool BuildGraph2(Graph *this_graph)
{
    FILE *fp;
    char address[1000];
    printf("请输入文件的地址（按回车键结束输入）：
");
    cin>>address;

    if((fp=fopen(address,"r"))==NULL)
        return false;

    if(fscanf(fp,"%d",&this_graph->city_number)==EOF)
        return false;

    for (int i=0;i<this_graph->city_number;i++)
    {
        for(int j=0;j<this_graph->city_number;j++)
        {
            if (i==j)
                this_graph->maps[i][j]=0;
            else
                this_graph->maps[i][j]=this_graph->maps[j][i]=inf;
        }
    }

    for(int i=0;i<this_graph->city_number;i++)
    {
        char name[1000];
        if(fscanf(fp,"%s",name)==EOF)
            return false ;
        city_numbers[name]=i;
        numbers_city[i]=name;
    }

    if(fscanf(fp,"%d",&this_graph->city_way)==EOF)
        return false;

    for(int i=0;i<this_graph->city_way;i++)
    {
        char start[1000],last[1000];
        int weight;
        if(fscanf(fp,"%s%s%d",start,last,&weight)==EOF)
             return false;
        this_graph->maps[city_numbers[start]][city_numbers[last]]=this_graph->maps[city_numbers[last]][city_numbers[start]]=weight;
    }

    fclose(fp);
    return true;
}
//从文件读入信息

bool cmp(Ways first,Ways last)
{
    return first.way_weight<last.way_weight;
}
 //排序条件

int find_parent(int parent[],int find_city)
{
    while(parent[find_city]>0)
    {
        find_city=parent[find_city];
    }
    return find_city;
}
//寻找根节点

void Putout1(Graph this_graph)
{
    int num=0;
    int parent[max_city];
    Ways way[max_city];
    memset(parent,0,sizeof(parent));

    for (int i=0;i<this_graph.city_number;i++)
    {
        for(int j=i+1;j<this_graph.city_number;j++)
        {
            if(this_graph.maps[i][j]!=inf)
            {
                way[num].way_begin=i;
                way[num].way_end=j;
                way[num++].way_weight=this_graph.maps[i][j];
            }
        }
    }
    //建立边集

    sort(way,way+num,cmp);
    //边集排序

    int sum=0;
    printf("最低经济方案如下如下：
");
    cout<<"编号"<<setw(8)<<"城市1"<<setw(8)<<"城市2"<<setw(8)<<"权值"<<endl;
    for (int i=0;i<this_graph.city_way;i++)
    {
        int n=find_parent(parent,way[i].way_begin);
        int m=find_parent(parent,way[i].way_end);
        //寻找首位两点的根

        if (n != m)
        {
            parent[n] = m;
            char city1[1000],city2[1000];
            cout<<++sum<<setw(8)<<numbers_city[way[i].way_begin]<<setw(8)<<numbers_city[way[i].way_end]<<setw(8)<<way[i].way_weight<<endl;
        }
        //假如n与m不等，说明两个顶点不会产生回路
    }
}
//直接输出结果

bool Putout2(Graph this_graph)
{
    int num=0;
    int parent[max_city];
    Ways way[max_city];
    memset(parent,0,sizeof(parent));

    for (int i=0;i<this_graph.city_number;i++)
    {
        for(int j=i+1;j<this_graph.city_number;j++)
        {
            if(this_graph.maps[i][j]!=inf)
            {
                way[num].way_begin=i;
                way[num].way_end=j;
                way[num++].way_weight=this_graph.maps[i][j];
            }
        }
    }
    //建立边集

    sort(way,way+num,cmp);
    //边集排序

    fstream fp;
    printf("请输入文件的地址（按回车键结束输入）：
");
    int sum=0;
    char address[1000];
    cin>>address;
    fp.open(address);

    if(!fp)
        return false;
    fp<<"最低经济方案如下如下："<<endl;
    fp<<"编号"<<setw(8)<<"城市1"<<setw(8)<<"城市2"<<setw(8)<<"权值"<<endl;
    for (int i=0;i<this_graph.city_way;i++)
    {
        int n=find_parent(parent,way[i].way_begin);
        int m=find_parent(parent,way[i].way_end);
        //寻找首位两点的根

        if (n != m)
        {
            parent[n] = m;
            char city1[1000],city2[1000];
            fp<<++sum<<setw(8)<<numbers_city[way[i].way_begin]<<setw(8)<<numbers_city[way[i].way_end]<<setw(8)<<way[i].way_weight<<endl;
        }
    }
    //假如n与m不等，说明两个顶点不会产生回路
    return true;
}
//打印到文件中

int main()
{
    int  ch;

    while(true)
    {

        printf("|-------------------------------------------------------|
");
        printf("|							|
");
        printf("|		  欢迎进入最小生成树系统！  		|
");
        printf("|							|
");
        printf("|-------------------------------------------------------|
");
        printf("|							|
");
        printf("|		    1——手动输入信息          		|
");
        printf("|		    2——从文件读入信息        		|
");
        printf("|		    0——退出系统        		|
");
        printf("|							|
");
        printf("|-------------------------------------------------------|
");
        printf("请输入选项编号（0 ～ 2）: （按回车键结束输入）
");

        Graph this_graph;
        cin>>ch;

        if(ch==0)
            break;

        if(ch==1)
            BuildGraph1(&this_graph);

        else if(ch==2)
        {
            if(!BuildGraph2(&this_graph))
            {
                printf("打开文件读入信息失败！
");
                continue;
            }
            printf("打开文件读入信息成功！
");
        }

        printf("|-------------------------------------------------------|
");
        printf("|							|
");
        printf("|		    1——直接输出结果          		|
");
        printf("|		    2——输出到文件        		|
");
        printf("|		    0——退出系统        		|
");
        printf("|							|
");
        printf("|-------------------------------------------------------|
");
        printf("请输入选项编号（0 ～ 2）: （按回车键结束输入）
");

        cin>>ch;
        if(ch==0)
            break;

        if(ch==1)
            Putout1(this_graph);

        else if(ch==2)
        {
            if(!Putout2(this_graph))
            {
                printf("打开文件输入信息失败！
");
                continue;
            }
            printf("打开文件输入信息成功！
");
        }
    }
}