数据结构课设———最小生成树问题代码+报告_最小生成树问题课程设计代码-CSDN博客

本文链接：https://blog.csdn.net/weixin_66170039/article/details/128193957
题目：

最小生成树问题设计要求：在n个城市之间建设网络，只需保证连通即可，求最经济的架设方法。存储结构采用多种。求解算法多种。
运行截图：

代码：

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#define MAX_VERTEX_NUM 20
#define OK 1
#define ERROR 0
#define MAX 1000
using namespace std;
typedef struct Arcell
{
    double adj;
}Arcell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];


typedef struct
{
    char vexs[MAX_VERTEX_NUM]; //节点数组
    AdjMatrix arcs; //邻接矩阵
    int vexnum,arcnum; //图的当前节点数和弧数
}MGraph;
typedef struct Pnode //用于普利姆算法
{
    char adjvex; //节点
    double lowcost; //权值
}Pnode,Closedge[MAX_VERTEX_NUM];//记录顶点集U到V-U的代价最小的边的辅助数组定义
typedef struct Knode//用于克鲁斯卡尔算法中存储一条边及其对应的2个节点
{
    char ch1; //节点1
    char ch2; //节点2
    double value;//权值
}Knode,Dgevalue[MAX_VERTEX_NUM];

int CreateUDG(MGraph & G,Dgevalue & dgevalue);
int LocateVex(MGraph G,char ch);
int Minimum(MGraph G,Closedge closedge);
void MiniSpanTree_PRIM(MGraph G,char u);
void Sortdge(Dgevalue & dgevalue,MGraph G);
void Adjacency_Matrix(MGraph G);
void Adjacency_List(MGraph G,Dgevalue dgevalue);

int CreateUDG(MGraph & G,Dgevalue & dgevalue)//构造无向加权图的邻接矩阵
{
    int i,j,k;
    cout<<"请输入城市个数及其之间的可连接线路数目：";
    cin>>G.vexnum>>G.arcnum;
    cout<<"请输入各个城市名称(分别用一个字符代替)：";
    for(i=0;i<G.vexnum;++i)
        cin>>G.vexs[i];
    for(i=0;i<G.vexnum;++i)//初始化数组
        for(j=0;j<G.vexnum;++j)
        {
            G.arcs[i][j].adj=MAX;
        }
    cout<<"请输入两个城市名称及其连接费用(严禁连接重复输入!)："<<endl;
    for(k=0;k<G.arcnum;++k)
    {
        cin >> dgevalue[k].ch1 >> dgevalue[k].ch2 >> dgevalue[k].value;
        i = LocateVex(G,dgevalue[k].ch1);
        j = LocateVex(G,dgevalue[k].ch2);
        G.arcs[i][j].adj = dgevalue[k].value;
        G.arcs[j][i].adj = G.arcs[i][j].adj;
    }
    return OK;
}
int LocateVex(MGraph G,char ch) //确定节点ch在图G.vexs中的位置
{
    int a ;
    for(int i=0; i<G.vexnum; i++)
        if(G.vexs[i] == ch)
            a=i;
    return a;
}

void Adjacency_Matrix(MGraph G)  //用邻接矩阵存储数据
{
	int i,j;
	for(i=0; i<G.vexnum; i++)
    {
        for(j=0; j<G.vexnum; j++)
            if(G.arcs[i][j].adj==MAX)
				cout<<0<<" ";
			else
				cout<<G.arcs[i][j].adj<<" ";
        cout<<endl;
    }
}
void Adjacency_List(MGraph G,Dgevalue dgevalue)  //用邻接表储存数据
{
	int i,j;
	for(i=0;i<G.vexnum;i++)
	{
		cout<<G.vexs[i]<<"->";
		for(j=0;j<G.arcnum;j++)
			if(dgevalue[j].ch1==G.vexs[i]&&dgevalue[j].ch2!=G.vexs[i])
				cout<<dgevalue[j].ch2<<"->";
			else if(dgevalue[j].ch1!=G.vexs[i]&&dgevalue[j].ch2==G.vexs[i])
				cout<<dgevalue[j].ch1<<"->";
		cout<<"\b\b  "<<endl;
	}
}
void MiniSpanTree_KRSL(MGraph G,Dgevalue & dgevalue)//克鲁斯卡尔算法求最小生成树
{
    int p1,p2,i,j;
    int bj[MAX_VERTEX_NUM]; //标记数组
    for(i=0; i<G.vexnum; i++) //标记数组初始化
        bj[i]=i;
    Sortdge(dgevalue,G);//将所有权值按从小到大排序
    for(i=0; i<G.arcnum; i++)
    {
        p1 = bj[LocateVex(G,dgevalue[i].ch1)];
        p2 = bj[LocateVex(G,dgevalue[i].ch2)];
        if(p1 != p2)
        {
            cout<<"   城市"<<dgevalue[i].ch1<<"与城市"<<dgevalue[i].ch2<<"连接。"<<endl;
            for(j=0; j<G.vexnum; j++)
            {
                if(bj[j] == p2)
                    bj[j] = p1;
            }
        }
    }
}
void Sortdge(Dgevalue & dgevalue,MGraph G)//对dgevalue中各元素按权值按从小到大排序
{
    int i,j;
    double temp;
    char ch1,ch2;
    for(i=0; i<G.arcnum; i++)
    {
        for(j=i; j<G.arcnum; j++)
        {
            if(dgevalue[i].value > dgevalue[j].value)
            {
                temp = dgevalue[i].value;
                dgevalue[i].value = dgevalue[j].value;
                dgevalue[j].value = temp;
                ch1 = dgevalue[i].ch1;
                dgevalue[i].ch1 = dgevalue[j].ch1;
                dgevalue[j].ch1 = ch1;
                ch2 = dgevalue[i].ch2;
                dgevalue[i].ch2 = dgevalue[j].ch2;
                dgevalue[j].ch2 = ch2;
            }
        }
    }
}
void MiniSpanTree_PRIM(MGraph G,char u)//普里姆算法求最小生成树
{
    int i,j,k;
    Closedge closedge;
    k = LocateVex(G,u);
    for(j=0; j<G.vexnum; j++)   //辅助数组初始化
	{
        if(j != k)
        {
            closedge[j].adjvex = u;
            closedge[j].lowcost = G.arcs[k][j].adj;
        }
	}
    closedge[k].lowcost = 0;
    for(i=1; i<G.vexnum; i++)
    {
        k = Minimum(G,closedge);
        cout<<"   城市"<<closedge[k].adjvex<<"与城市"<<G.vexs[k]<<"连接。"<<endl;
        closedge[k].lowcost = 0;
        for(j=0; j<G.vexnum; ++j)
        {
            if(G.arcs[k][j].adj < closedge[j].lowcost)
            {
                closedge[j].adjvex = G.vexs[k];
                closedge[j].lowcost= G.arcs[k][j].adj;
            }
        }
    }
}
 int Minimum(MGraph G,Closedge closedge) //求closedge中权值最小的边，并返回其顶点在vexs中的位置
{
    int i,j;
    double k = 1000;
    for(i=0; i<G.vexnum; i++)
    {
        if(closedge[i].lowcost != 0 && closedge[i].lowcost < k)
        {
            k = closedge[i].lowcost;
            j = i;
        }
    }
    return j;
}

int main()
{
    MGraph G;
    Dgevalue dgevalue;
    CreateUDG(G,dgevalue);
	char u;
 cout<<"图创建成功。";
 cout<<"请根据如下菜单选择操作。\n";
 cout<<"1、用邻接矩阵存储："<<endl;
 cout<<"2、用邻接表存储："<<endl;
 cout<<"3、克鲁斯卡尔算法求最经济的连接方案"<<endl;
 cout<<"4、普里姆算法求最经济的连接方案"<<endl;
 int s;
 char y='y';
 while(y='y')
 {
  cout<<"请选择菜单："<<endl;
  cin>>s;
  switch(s)
  {
  case 1:
   cout<<"用邻接矩阵存储为："<<endl;
   Adjacency_Matrix(G);
   break;
  case 2:
   cout<<"用邻接表存储为："<<endl;
   Adjacency_List(G,dgevalue);
   break;
  case 3:
   cout<<"克鲁斯卡尔算法最经济的连接方案为:"<<endl;
   MiniSpanTree_KRSL(G,dgevalue);
   break;
  case 4:
   cout<<"普里姆算法最经济的连接方案为:"<<endl;
   cout<<"请输入起始城市名称：";
   cin>>u;
   MiniSpanTree_PRIM(G,u);
   break;
  default:
	  cout<<"输入有误!";
   break;
  }
  cout<<endl<<"是否继续？y/n:";
   cin>>y;
  if(y=='n')
   break;
 }
}