最小生成树问题

@ancery

中 北 大 学
课程设计任务书

学 院： 软件学院
专 业： 软件工程
学 生 姓 名： 秦鸿 学 号： 1614010948
设 计 题 目： 最小生成树问题
起 迄 日 期: 2018年12月31日~ 2019年1月11日
设计地点: 软件学院机房
指导教师: 马巧梅

发任务书日期:2018 年12月31日

课 程 设 计 任 务 书
1．设计目的：
《数据结构》课程主要介绍最常用的数据结构，阐明各种数据结构内在的逻辑关系，讨论其在计算机中的存储表示，以及在其上进行各种运算时的实现算法，并对算法的效率进行简单的分析和讨论。进行数据结构课程设计要达到以下目的：
了解并掌握数据结构与算法的设计方法，具备初步的独立分析和设计能力；
初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能；
提高综合运用所学的理论知识和方法独立分析和解决问题的能力；
训练用系统的观点和软件开发一般规范进行软件开发，培养软件工作者所应具备的科学的工作方法和作风。
2．设计内容和要求：
设计内容：
在n个城市（n>=5）之间建设网络，只需保证连通即可，求最经济的架设方法。存储结构采用（邻接表和邻接矩阵）两种，采用课本上的两种求解算法。

设计要求：
(1) 符合课题要求，实现相应功能；
(2) 要求界面友好美观，操作方便易行；
(3) 注意程序的实用性、安全性。

3．设计工作任务及工作量的要求〔包括课程设计说明书、程序等〕：
(1) 选择合适的数据结构，并定义数据结构的结构体；
(2) 根据程序所要完成的基本要求和程序实现提示，设计出完整的算法；
(3) 按格式要求写出课程设计说明书。

课 程 设 计 任 务 书
4．主要参考文献：
[1] 李云清，杨庆红.数据结构（C语言版）.北京：人民邮电出版社，2004.
[2] 严蔚敏,吴伟民.数据结构（C语言版）.北京：清华大学出版.1997.
[3] 苏光奎,李春葆.数据结构导学.北京:清华大学出版.2002.
[4] 周海英，马巧梅，靳雁霞.数据结构与算法设计.北京：国防工业出版社，2007.
[5] 张海藩. 软件工程导论. 北京：清华大学出版社.2003.

5．设计成果及要求：
应用软件
课程设计说明书
6．工作计划及进度：
2018年12月31 日 ~ 2019年1 月2日 需求分析和概要设计；
2019年1月 3 日 ~ 2019年1 月9日 详细设计及编码；
2019年1 月9日 ~ 2019 年1 月10日 撰写课程设计说明书；
2019年1月 11日 验收、成绩考核。
学院审查意见：

                                         签字：          

2018年12月31日

中 北 大 学
数据结构课程设计说明书

学 院、系： 软件学院
专 业： 软件工程
班 级： 16140Y06
学 生 姓 名： 秦鸿 学 号： 1614010948
设 计 题 目： 最小生成树问题
起 迄 日 期: 2018年12月31日~ 2019年1月11日
指 导 教 师: 马巧梅

日期: 2019年1月11日

1 设计目的
《数据结构》课程主要介绍最常用的数据结构，阐明各种数据结构内在的逻辑关系，讨论其在计算机中的存储表示，以及在其上进行各种运算时的实现算法，并对算法的效率进行简单的分析和讨论。进行数据结构课程设计要达到以下目的：
了解并掌握数据结构与算法的设计方法，具备初步的独立分析和设计能力；
初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能；
提高综合运用所学的理论知识和方法独立分析和解决问题的能力；
训练用系统的观点和软件开发一般规范性软件开发，培养软件工作者所应具备的科学的工作方法和作风。
2 任务概述
每个城市可以表示成城市网中的顶点，城市间的距离可以用距离网中的边表示，边的权值表示两地间的直接路径，采用Kruskal算法建立最小生成树，历城市生成最小生成树，通过计算得到最小生成树的代价。
3 本设计采用的数据结构
数据类型定义：
typedef struct node /构造一个结构体，两个城市可以看成起点和终点， 之间的道路可以看成一个边/
{
int str; /起点/
int end; /终点/
int dis; /距离/
}node;
typedef struct{ //邻接矩阵存储图结构
int vexs[MAX_LNT]; //数组用于存储城市数
int adj[max+1][max+1]; //图的邻接矩阵表示
int n,e; //n代表城市数，e代表城市间边数
}graph;
}
函数实现代码：
a) int main ( ) //主程序 b) int menu ( ) //菜单函数 c) void create ( ) //输入城市信息函数
d) void judge ( ) //判断是否能够生成最小生成树函数
e) void display( ) //打印输出
f) void set ( ) //初始化pre[],rank[]函数
g) void find ( ) //判断是否构成回路函数
h) void Union ( ) //将能构成最小生成树的边添加到一个集合
l） void Krushal( ) //克鲁斯算法求最小生成树
函数之间的调用关系：
程序执行从主函数main（）开始，首先在运行界面上显示菜单，调用菜单函menu( )，根据switch函数选择调用的函数，其中选择1，调用create（）函数，用来创建城市之间距离的图，选择2，调用judge()函数，用来判断输入的图是否能够产生最小生成树，选择3，调用display()函数，用来显示最小生成树，而函数本身也存在函数的调用，在display()函数中调用 Kruskal()函数，该函数式用克鲁斯卡尔算法求最小生成树，而Kruskal()函数中又调用三个函数set()，find()，Union()，它们作用是检验当一条边添加进去，是否会产生回路。

4 主要函数说明及其程序流程图

                     图4.1程序流程图















                   图4.2最小生成树主要功能图

5 程序运行数据及其结果

             图5.1输入城市之间的信息


             图5.2遍历所有城市生成最小生成树

6 课程设计心得
该次所做题目为最小生成树问题，涵盖内容为图的邻接矩阵、邻接表的存储，普利姆算法、克鲁斯卡尔算法。通过算法的编写，我学到的最重要的方法是标记，从而减少算法的时间复杂度。除了课内知识外，还学到了许多新东西。在做课程设计是要有信心，有耐心，切勿浮躁；出现差错时要随机应变。无论是邻接表（链式存储）或邻接矩阵（顺序存储）存储方式的差异，还是Prim或Kruscal算法的不同思想，我都从中学到了许多方法。如用标记法求连通分量数是在几天没有进展后突然冒出的新想法，其实是在几天的尝试和积累中才摸索出的规律；又如Prim算法中赋值时，0和无穷都有其特定的作用，不能随意交换；调试程序过程中也有许多及其不易发现的错误，看似正确的语句仍存在漏洞，只有多次验证后才能找出问题核心，需要细心细心再细心、考虑的更全面才行。测试用例的选择也是至关重要的，如果选取不当则很难发现严重的逻辑错误。总之，只有专注的思考，不断的探求新方法，追求更小时间、空间复杂度的好算法，才能设计出有自己独特风格的好程序。

#include <stdio.h> 
#include <string.h> 
#include <stdlib.h>  
#define max 20               //城市间边数
#define MAX_LNT 10         //城市数
#define INF 32627            //两个城市间无直接路径，用大数32627表示
typedef struct node          /*构造一个结构体，两个城市可以看成起点和终点，之间的道路可以看成一个边*/ 
{
        int str;             /*起点*/ 
        int end;            /*终点*/ 
        int dis;            /*距离*/ 
        }node;  
node p[max],temp;          /*p记录城市信息*/  
typedef struct{             //邻接矩阵存储图结构
int vexs[MAX_LNT];        //数组用于存储城市数
int adj[max+1][max+1];      //图的邻接矩阵表示
int n,e;                    //n代表城市数，e代表城市间边数
}graph; 
int pre[100],rank[100];        /*用于判断是否构成回路*/  
//int arcs[MAX_LNT][MAX_LNT];/*n表示城市个数，arcs[][]记录城市间权值*/ 
int menu()                /*菜单函数*/ 
{ 
    int m; 
    printf("            求最小生成树              \n"); 
    printf("  ************************************\n\n"); 
    printf("  1:输入城市之间的信息\n"); 
    printf("  2:判断是否能构成一个最小生成树\n"); 
    printf("  3:遍历所有城市生成最小生成树\n"); 
    printf("  4:退出\n"); 
    printf(" ************************************\n\n"); 
    printf("  请输入所选功能(1-4):"); 
    scanf("%d",&m);  
    return m; 
    } 
    void create(graph *g) /*输入城市信息*/ 
    { 
         int i,j,k; 
         printf("输入城市数为:"); 
         scanf("%d",&(g->n)); 
         printf("\n"); 
         printf("输入n个城市间边数为:");  
         scanf("%d",&(g->e)); 
         printf("输入城市的各个顶点为:");  
         for(i=0;i<(g->n);i++) 
         scanf("%d",&(g->vexs[i])); //顶点存入数组vexs[] 
         printf("输入%d条边，建立邻接矩阵",(g->e)); 
         printf("\n"); 
         for(i=0;i<(g->n);i++) //初始化邻接矩阵
         { 
             for(j=0;j<(g->n);j++) 
             { 
                 if(i==j) 
                 g->adj[i][j]=0; 
                 else 
                 g->adj[i][j]=INF; 
             } 
         } 
         printf("请输入具有邻接关系的两个顶点在矩阵中所在的行与列及权值:\n"); 
         for(k=0;k<(g->e);k++) //有g->e条边，即有g->e个权值
         { 
            scanf("%d,%d",&i,&j); 
            scanf("%d",&g->adj[i][j]); 
            }
            for(i=0;i<(g->n);i++) 
            for(j=0;j<(g->n);j++) 
            g->adj[j][i]=g->adj[i][j]; 
            printf(" 图的邻接矩阵如下\n"); 
            for(i=0;i<(g->n);i++) 
            //输出邻接矩阵g 
            { 
               for(j=0;j<(g->n);j++) 
               if(g->adj[i][j]==INF) 
               printf("\t%3s","∞"); 
               else 
               printf("\t%3d",g->adj[i][j]); 
               printf("\n"); 
            } 
} 
/*下面三个函数作用是检验当一条边添加进去，是否会产生回路*/ 
void set(int x)/*初始化*/ 
{ 
     pre[x] = x;
     rank[x] = 0; 
     } 
     int find(int x)/*找到这个点的祖先*/ 
     { 
         if(x != pre[x])  
         pre[x] = find(pre[x]); 
         return pre[x]; 
         } 
void Union(int x,int y)/*将这两个添加到一个集合里去*/ 
{ 
     x = find(x); 
     y = find(y); 
     if(rank[x] >= rank[y]) 
     { 
                pre[y] = x; 
                rank[x] ++; 
                } 
                else 
                pre[y] = x; 
                }  
void Kruskal(graph *g ) 
{ 
     int ans = 0,i,j,k = 0;  /*ans用来记录生成最小树的权总值*/  
     int index; 
     int count = 0; /*记录打印边的条数*/ 
     for(i = 0;i<(g->n);i ++) /*初始化数组pre[x],rank[x]*/ 
     set(i); 
     for(i = 0;i<(g->n);i ++)  
     { 
           for(j = i + 1;j <(g->n);j ++) 
           { 
                 p[++k].str = i; 
                 p[k].end = j; 
                 p[k].dis = g->adj[i][j]; /*先把所有城市之间的路段看成一个边*/ 
           } 
     }
     for(i=0;i<k;i++) /*把所有的边按从小到大进行排序*/ 
     { 
        index=i; 
        for(j=i+1;j<=k;j++) 
        if(p[j].dis <p[index].dis) 
        index=j; 
        temp=p[index]; 
        p[index]=p[i]; 
        p[i]=temp;  
        } 
        for(i = 0;i < k;i ++) 
        { 
           if(find(p[i].str) != find(p[i].end))/*如果这两点连接在一起不构成一个回路，则执行下面操作*/ 
           { 
              printf("\t第%d条路段为：%d--%d,权值为%d\n",++count,p[i].str,p[i].end,p[i].dis);/*将这条边的起点、终点打印出来*/ 
              ans += p[i].dis; /*说明这条路段要用*/ 
              Union(p[i].str,p[i].end); 
           } 
        } 
        printf("\t遍历所有城市得到最小生成树的代价为: %d\n\n",ans); 
}  
void display( graph *g ) /*显示生成的最小生成树*/ 
{ 
     if((g->n)==0) 
     { 
         printf("这里没有城市之间的信息\n"); 
         return; 
     } 
     printf("遍历所有城市得到最小生成树为：\n\n\n"); 
     Kruskal(g); 
}  
void judge(graph *g )/*判断是否能够生成最小生成树*/ 
{ 
     int close[100],low[100],i,j,ans = 0;/*close[j]表示离j最近的顶点，low[j]表示离j最短的距离*/ 
     int use[100]; 
     use[1] = 1;
     for(i = 1;i<(g->n);i++) 
     { 
           low[i]=g->adj[1][i]; /*初始化*/ 
           close[i] = 1; 
           use[i] = 0; 
     }  
     for(i=0;i<(g->n);i++) 
     { 
         int min = 100000000,k = 0; 
         for(j=1;j<(g->n);j ++) 
         {
             if(use[j] == 0 && min > low[j])/*找到最小的low[]值，并记录*/ 
             { 
                   min = low[j]; 
                   k = j; 
             } 
         } 
         for(j =1;j < (g->n);j ++) 
           { 
               if(use[j] == 0 && low[j] >( g->adj[k][j])) 
               { 
                  low[j] = g->adj[k][j]; /*修改low[]值和close[]值*/ 
                  close[j] = k; 
               } 
           }
           ans += g->adj[close[k]][k]; 
      } 
      if(ans >= 100000000) 
      printf("不能构成最小生成树\n"); 
      else 
      printf("能构成最小生成树\n"); 
}  
int main( ) /*主函数*/ 
{ 
    graph *g=(graph*)malloc(sizeof(graph)); 
    while(1) { 
             switch( menu( ) ) 
             { 
                     case 1:create(g);break;/*输入城市信息*/ 
                     case 2:judge(g);break;/*判断是否能够生成最小生成树*/ 
                     case 3:display(g);break; /*显示生成的最小生成树*/ 
                     case 4:exit(0); 
             } 
    } 
    return 0; 
}

运行结果：