数据结构课程设计

最新推荐文章于 2024-10-08 14:26:15 发布

lin17171717

最新推荐文章于 2024-10-08 14:26:15 发布

阅读量344

点赞数 11

文章标签：数据结构课程设计

本文链接：https://blog.csdn.net/qq_39368811/article/details/135274590

版权

题目要求

设一个企业有六个网点，连接这六个网点的可选线路有十条，每条线路的代价不同。要求

输入这些网点、边以及代价，生成邻接矩阵。
用Prime算法生成最小生成树并输出边及其权值。
用Kruskal算法生成最小生成树并输出边及其权值。

将邻接矩阵压缩存储到一维数组中，给出行列号能在一维数组中查询并输出其权值

主要任务

定义边集数组
初始化图的边集数组
根据图的边集生成图的边集数组
创建邻接矩阵
写出prim算法
写出Kruskal算法
将邻接矩阵压缩存储到一维数组
按升序按照边集数组的权值冒泡排序
建立给网点命名函数、

主要源代码及说明

#include<iostream>

#include<stdlib.h>

using namespace std;

#include<strstream>

typedef int WeightType;

typedef int VertexType;

const int MaxVertexNum=10;

const int MaxEdgeNum=20;

const WeightType MaxValue=1000;

typedef VertexType vexlist[MaxVertexNum];

typedef int num[6*(6+1)/2];

typedef int adjmatrix[MaxVertexNum][MaxVertexNum];

//定义边集数组

struct edge{

int fromvex;//初始边

int endvex;//终止边

WeightType weight;//权值

string name;//网点名字

};

typedef edge edgeset[MaxEdgeNum];

//初始化图的边集数组

void InitArray(edgeset GE){

for(int i=0;i<MaxEdgeNum;i++){

GE[i].fromvex=GE[i].endvex=-1;

GE[i].weight=MaxValue;

}

}

//根据图的边集生成图的边集数组

void CreatArray(edgeset GE,int n,char*s,int k){

//k为0为无权图否则为有权图；

istrstream sin(s);

char c1,c2,c3;

int i,j,c=0;

WeightType w;

sin>>c1;

if(k==0){

//建立无权图；

do{

//从输入流中读入一条边；

 sin>>c1>>i>>c2>>j>>c3;

 //置边集数组中下标为c的元素值

 GE[c].fromvex=i;

 GE[c].endvex=j;

 GE[c].weight=1;//假定无权图的每条边的权为1；

 c++;

//读入逗号或右花括号；

 sin>>c1;

}while(c1==',');

}

else{

//建立有权图

do{

//从输入流中读入一条边

sin>>c1>>i>>c2>>j>>c3>>w;

//置边集数组中下标为c的元素值

 GE[c].fromvex=i;

 GE[c].endvex=j;

 GE[c].weight=w;

 c++;

 //读入逗号或右花括号；

 sin>>c1;

}while(c1==',');

}

}

//创建邻接矩阵

void CreateMatrix(adjmatrix GA,int n,char*s,int k1, int k2){

//k1==0:无向图； k1==1:有向图

// k2==0：无权图；k2==1:有权图

//s字符串表示边集，n为顶点数

istrstream sin(s);//定义输入流

char c1,c2,c3;//用来保存从输入流中读入的字符；

int i,j;//用i，j，保存一条边的起点和终点序号；

WeightType w;//用w保存一条边的权值

sin>>c1;//从sin输入流中读取第一个字符‘{’

if(k1==0 && k2==0)

  do{

    sin>>c1>>i>>c2>>j>>c3;//读入(i,j)

    GA[i][j]=GA[j][i]=1;

    sin>>c1;//读入逗号或花括号

    if(c1=='}') break;

 }while(1);

else if(k1==0 && k2!=0)//建立无向有权图

  do{

    sin>>c1>>i>>c2>>j>>c3>>w;

    GA[i][j]=GA[j][i]=w;//置相应的对称元素为w；

    sin>>c1;

    if(c1=='}') break;

 }while(1);

else if(k1!=0 && k2==0)//建立有向无权图

  do{

    sin>>c1>>i>>c2>>j>>c3;

    GA[i][j]=1;//置相应的元素为1；

    sin>>c1;

    if(c1=='}') break;

  }while(1);

else if(k1!=0 && k2!=0)//建立有向有权图

  do{

   sin>>c1>>i>>c2>>j>>c3>>w;

   GA[i][j]=w;//置相应的元素为w

   sin>>c1;

   if(c1=='}') break;

 }while(1);

}

//初始化邻接矩阵

void InitMatrix(adjmatrix GA,int k) {

 //k==0：无权图；k==1:有权图。

int i,j;

for(i=0;i<MaxVertexNum;i++)

   for(j=0;j<MaxVertexNum;j++)

     if(i==j) GA[i][j]=0;

     else if(k) GA[i][j]=MaxValue;

     else GA[i][j]=0;

}

//Prim算法

void prim(adjmatrix GA,edgeset CT,int n){

//利用普利姆算法 从顶点v0出发求用邻接矩阵GA表示的图的

//最小生成树，最小生成树的边集存于数组CT中；

int i,j,k,min,t,m,w;

//给CT赋初值，对应第0次的LW值；

for(i=0;i<n-1;i++){

CT[i].fromvex=0;

CT[i].endvex=i+1;

CT[i].weight=GA[0][i+1];

}

//进行n-1次循环，每次求出最小生成树中的第k条边；

for(k=1;k<n;k++){

//从CT[k-1]~CT[n-2](即LW）中查找最短边CT[m]

min=MaxValue;

m=k-1;

for(j=k-1;j<n-1;j++)

if(CT[j].weight<min){

min=CT[j].weight;

m=j;

}

//最短边对调到第k-1下标位置；

edge temp=CT[k-1];

CT[k-1]=CT[m];

CT[m]=temp;

//把新并入最小生成树T中的顶点序号赋给j

j=CT[k-1].endvex;

//修改LW中的有关边，使T中到T外的每一个顶点各保持

//一条到目前为止最短的边；

for(i=k;i<n-1;i++){

t=CT[i].endvex;

w=GA[j][t];

if(w<CT[i].weight){

CT[i].weight=w;

CT[i].fromvex=j;

}

}//内for end；

} //外for end；

}

//Kruskal算法

void Kruskal(edgeset GE,edgeset CT,int n){

//求边集数组GE所示图的最小生成树，树中每条边依次存于数组CT中；

int i,j;

//定义具有n*n个元素的动态分配的二维数组s

bool**s=new bool*[n];

for(i=0;i<n;i++)

s[i]=new bool[n];

//初始化s集合，使每一个顶点分属于对应集合；

for(i=0;i<n;i++){

for(j=0;j<n;j++)

if(i==j)

s[i][j]=true;

else s[i][j]=false;

}

//定义相应变量

int k=1;//k表示待获取的最小生成树的边数，初值为1；

int d=0;//d表示GE中待扫描边元素的下标位置，初值为0；

int m1,m2;//m1和m2分别保存一条边的两个顶点所在集合的序号；

//进行n-1次循环，得到最小生成树中的n-1条边；

while(k<n){

for(i=0;i<n;i++){

//求出边GE[d]的两个顶点所在集合的序号m1和m2；

if(s[i][GE[d].fromvex]==true)

m1=i;

if(s[i][GE[d].endvex]==true)

m2=i;

}

if(m1!=m2){

//若两集合序号不等，则表明GE[d]是生成树的一条边；

//应将他加入到数组CT中；

CT[k-1]=GE[d];

k++;

for(j=0;j<n;j++){

//合并两个集合，并将另一个置为空集

s[m1][j]=s[m1][j]||s[m2][j];

s[m2][j]=false;

}

}

d++;//d后移一个位置，以便扫描GE中的下一条边；

}

//释放为s动态分配的数组空间；

for(i=0;i<n;i++)

delete[]s[i];

delete[]s;

}

//将邻接矩阵压缩存储到一维数组中

void find(adjmatrix GA,num Num,int n){

for(int i=0;i<n;i++)

for(int j=0;j<n;j++){

int k;

if(i>=j)

k=i*(i+1)/2+j;

else

k=j*(j+1)/2+i;

Num[k]=GA[i][j];

}

    while(1){

     int k;

     cout<<"输入查找邻接矩阵行数"<<endl;

int row;

cin>>row;

cout<<"输入查找邻接矩阵列数"<<endl;

int column;

cin>>column;

if(row>=column){

k=row*(row+1)/2+column;

if(Num[k]!=0&&Num[k]!=MaxValue)

cout<<"权值： "<<Num[k]<<endl;

else

cout<<"此处无权值"<<endl;

}

else{

 k=column*(column+1)/2+row;

 if(Num[k]!=0&&Num[k]!=MaxValue)

 cout<<"权值： "<<Num[k]<<endl;

 else

cout<<"此处无权值"<<endl;

}

cout<<"是否继续（1为继续查找，其他则不继续查找)"<<endl;

char tbd;

cin>>tbd;

if(tbd!='1')

break;

}

}

//冒泡排序边集数组的权值从小到大

void sort(edgeset GE,int side){

edge t;

for(int i=0;i<side-1;i++)//n个数的数列总共扫描n-1次

    {

        for(int j=0;j<side-i-1;j++)//每一趟扫描到a[n-i-2]与a[n-i-1]比较为止结束

        {

            if(GE[j].weight>GE[j+1].weight)//后一位数比前一位数小的话，就交换两个数的位置（升序）

            {

               t=GE[j+1];

               GE[j+1]=GE[j];

               GE[j]=t;

            }

        }

    }

    cout<<"权值从小到大排列为："<<endl;

    for(int i=0;i<side-1;i++)

    cout<<"  "<<GE[i].weight;

    cout<<endl;

}

//给网点赋予名字

void outletsname(edgeset CT,int n){

for(int i=0;i<n;i++){

cout<<"给第"<<i<<"个网点赋予名字:"<<endl;

string name0;

cin>>name0;

CT[i].name=name0;

}

}

int main()

{

int i,n,k1,k2;

cout<<"输入网点数"<<endl;

cin>>n;

cout<<"输入网点的有无向和有无权选择（0为无，非0为有）：";

cin>>k1>>k2;

bool*visited=new bool[n];

adjmatrix ga;

InitMatrix(ga,k2);

cout<<"输入网点、边以及代价"<<endl;

char*a=new char[100];

cin>>a;

CreateMatrix(ga,n,a,k1,k2);

edgeset CT;

edgeset ET;

edgeset DT;

edgeset PT;

outletsname(PT,6);

cout<<"Prime算法生成最小生成树并输出边及其权值" <<endl;

prim(ga,CT,n);

for(int i=0;i<n-1;i++){

cout<<"起始网点： "<<CT[i].fromvex<<" 网点名： "<<PT[CT[i].fromvex].name;

cout<<"  代价："<<CT[i].weight<<"   ";

cout<<"结束网点:"<<CT[i].endvex<<" 网点名： "<<PT[CT[i].endvex].name<<endl;;

}

cout<<"Kruskal算法生成最小生成树并输出边及其权值" <<endl;

InitArray(ET);

CreatArray(ET,n,a,k2);

sort(ET,10);

cout<<"将边集数组按权值从小到大排列完毕"<<endl;

Kruskal(ET,DT,n);

for(int i=0;i<n-1;i++){

cout<<"起始网点："<<DT[i].fromvex<<" 网点名： "<<PT[DT[i].fromvex].name;

cout<<"  代价："<<DT[i].weight<<"   ";

cout<<"结束网点:"<<DT[i].endvex<<" 网点名： "<<PT[DT[i].endvex].name<<endl;

}

num Num;

find(ga,Num,n);

return 0;

}