數據結構實驗六 最小生成樹—Prim-Kruskal

#include <iostream>
#include "stdio.h"
#include "stdlib.h"
#include "cstdlib"//syste()函數需要該頭文件；

using namespace std;

#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;

#define MaxInt 32767 //網中表示極大值，即∞,若為無向圖，Mxint 0；

//#define INFINITY 0//圖中表示初始值0；網中表示極大值，即∞.在無向圖中不存在權，用這個單詞比Maxint含義好
#define MVNum 100 //最大頂點數
#define MENum 20 //最大邊數
//00定義 點 邊 圖網

typedef char VerTexType; //假設頂點的數據類型為字符型
typedef int ArcType; //假設邊的權值類型為整型，若為無向圖，ArcType->EdgeType
typedef struct{
　　VerTexType vexs[MVNum]; //頂點表
　　ArcType arcs[MVNum][MVNum]; //鄰接矩陣
　　int vexnum,arcnum; //圖的當前點數和邊數
}AMGraph;

//01 定位Locate the vertex you need
int LocateVex(AMGraph G,char ch)
{
　　int i=0;
　　for(i=0; i<G.vexnum;i++)
　　{
　　　　if(G.vexs[i]==ch)
　　　　break;
　　}

　　if(i>=G.vexnum) //如果超過頂點數量了，返回-1
　　　　return -1;

　　return i; //return the index of the vertex you are looking
}
//02 打印 頂點（一維數組） 邊（二維數組）
Status PrintAMGraphVex(AMGraph G)//打印頂點，一維數組
{
　　int i;
　　printf("你輸入的頂點是：");
　　for(i=0;i<G.vexnum;i++)
　　{
　　　　printf("%c\t",G.vexs[i]);
　　}
　　printf("\n");
　　return OK;
}
Status PrintAMGraphArc(AMGraph G)//打印鄰接矩陣，二維數組
{
　　int i,j;
　　cout<<"當前鄰接矩陣是："<<endl;
　　for(i=0;i<G.vexnum;i++)
　　{
　　　　for(j=0;j<G.vexnum;j++)
　　　　{
　　　　　　printf("%d\t",G.arcs[i][j]);
　　　　}
　　　　printf("\n\n\n");
　　}
　　return OK;
}

//03 建立一個無方向網圖的鄰接矩陣表示
Status CreateGraph(AMGraph &G)
{
　　int i,j,k,w;
　　char v1,v2;

　　printf("Input the number of vertex and arc:\n");
　　cin>>G.vexnum>>G.arcnum;
　　printf("The number is %d and %d.\n",G.vexnum,G.arcnum);//驗證輸入內容
　　//initialize vertex arcs;
　　printf("Input %d vertex: ",G.vexnum);
　　for(i=0;i<G.vexnum;++i)
　　cin>>G.vexs[i];
　　PrintAMGraphVex(G);//驗證輸入的頂點
　　for(i=0;i<G.vexnum;++i)
　　　　for(j=0;j<G.vexnum;++j)
　　　　　　{
　　　　　　　　// if(i!=j)
　　　　　　　　　　G.arcs[i][j]=MaxInt;//無窮
　　　　　　　　// else
　　　　　　　　　　// G.arcs[i][j]=0;
　　　　　　}
　　PrintAMGraphArc(G);//驗證輸入的邊

　　for (k = 0; k < G.arcnum; ++k)
　　{
　　　　printf("input the i and j of (Vi,Vj), and the weight:\n"); //一條邊的兩個結點，和這條邊的權重,無向圖權值輸入1；也可以前面聲明為1.
　　　　cin>>v1>>v2>>w;
　　　　//cout<<"你輸入的v1 v2 w :"<<v1<<v2<<w<<endl;
　　　　i=LocateVex(G,v1);
　　　　j=LocateVex(G,v2);
　　　　//cout<<"i:"<<i<<" ";
　　　　//cout<<"j:"<<j<<endl;
　　　　if(i==-1 || j==-1)
　　　　{
　　　　　　return ERROR;
　　　　}
　　　　G.arcs[i][j]=w;
　　　　G.arcs[j][i]=G.arcs[i][j];//如果是有向網，可以w1 w2
　　　　//cout<<"G.arcs[i][j] :"<<G.arcs[i][j]<<endl;
　　}
　　return OK;
}

//普利姆算法
struct Node //需要用一個結構體來記錄產生的最小的生成樹
{
　　VerTexType adjvex;//最小邊在U的那個頂點
　　ArcType lowcost;//最小邊上的權值
}closedge[MVNum];

void MiniSpanTree_Prim(AMGraph G,VerTexType u)
{
　　int i,j,k;
　　k=LocateVex(G,u);

　　//初始化closedge
　　for(j=0;j<G.vexnum;j++)
　　{
　　　　if(j!=k)//i!=k是因為結點本身和結點本身不能產生關系
　　　　　　{
　　　　　　　　closedge[j].adjvex=u;
　　　　　　　　closedge[j].lowcost=G.arcs[k][j];
　　　　　　}
　　}
　　closedge[k].lowcost=0;//初始，U={u};

　　VerTexType u0,v0;
　　int min,sum=0;
　　printf("最小生成樹：\n");
　　for(i=1;i<G.vexnum;i++)//n-1是因為已經有一個頂點已經遍歷了
　　{
　　　　min=MaxInt;//k=Min(closedge)
　　　　for(int j=0;j<G.vexnum;j++)
　　　　{
　　　　　　if(closedge[j].lowcost>0)
　　　　　　{
　　　　　　　　if(closedge[j].lowcost<min)
　　　　　　　　　　{
　　　　　　　　　　　　k=j;
　　　　　　　　　　　　min=closedge[j].lowcost;
　　　　　　　　　　}
　　　　　　}
　　　　}
　　　　u0=closedge[k].adjvex;
　　　　v0=G.vexs[k];
　　　　cout<<u0<<v0<<endl;
　　　　sum+=closedge[k].lowcost;

　　　　closedge[k].lowcost=0;//還要修改closedge數組
　　　　for(j=0;j<G.vexnum;j++)
　　　　{
　　　　　　if(G.arcs[k][j]<closedge[j].lowcost)
　　　　　　{
　　　　　　　　closedge[j].lowcost=G.arcs[k][j];
　　　　　　　　closedge[j].adjvex=G.vexs[k];
　　　　　　}
　　　　}
　　}
　　printf("最小路徑長度為：%d\n",sum);
}

//Kruskal算法

struct EdgeNode //需要用一個結構體來記錄產生的最小的生成樹
{
　　VerTexType Head;//邊的始點
　　VerTexType Tail;//邊的終點
　　ArcType lowcost;//邊的權值
}Edge[2*MENum];

Status Sort(EdgeNode a[])//從小到大
{
　　int i,j;
　　EdgeNode temp;
　　for(i=0;i<2*MENum;i++)
　　　　for(j=0;j<2*MENum;j++)
　　　　　　if(a[j].lowcost>a[j+1].lowcost)
　　　　　　　　{
　　　　　　　　　　temp=a[j];
　　　　　　　　　　a[j]=a[j+1];
　　　　　　　　　　a[j+1]=temp;
　　　　　　　　}
　　return OK;
}

void MiniSpanTree_Kruskal(AMGraph G)
{
　　int i,j,v1,v2,vs1,vs2,k=0,Vexset[MVNum];//需要用到並查集，看是否選出的邊的兩個頂點是否已經歸並，避免形成回路.
　　for(i=0;i<G.vexnum;i++)
　　Vexset[i]=i;//初始化,各自是只有一個結點的連通分量，避免回路
　　//初始化Edge
　　for(i=0;i<G.vexnum;i++)
　　　　for(j=0;j<G.vexnum;j++)
　　　　　　if(G.arcs[i][j]<MaxInt)
　　　　　　　　{
　　　　　　　　Edge[k].Head=G.vexs[i];
　　　　　　　　Edge[k].Tail=G.vexs[j];
　　　　　　　　Edge[k].lowcost=G.arcs[i][j];
　　　　　　　　k++;
　　　　　　　　}
　　for(k;k<=2*MENum;k++)//開辟數組只能定值，空間用不完，后面要填一個大值，因為sort從小到大，而數組默認0
　　　　{
　　　　　　Edge[k].lowcost=MaxInt;
　　　　}

　　//從小到大排序
　　Sort(Edge);
　　cout<<"Edge[]數組是：\n";
　　for(i=0;i<2*G.arcnum;i++)
　　　　cout<<Edge[i].Head<<Edge[i].Tail<<Edge[i].lowcost<<endl;
　　

　　cout<<"最小生成樹：\n";
　　int sum=0;
　　for(i=0;i<2*G.arcnum;i++)
　　　　{
　　　　　　v1=LocateVex(G,Edge[i].Head);
　　　　　　v2=LocateVex(G,Edge[i].Tail);
　　　　　　vs1=Vexset[v1];
　　　　　　vs2=Vexset[v2];
　　　　　　if(vs1!=vs2)
　　　　　　{
　　　　　　　　cout<<Edge[i].Head<<Edge[i].Tail<<endl;
　　　　　　　　sum+=Edge[i].lowcost;
　　　　　　　　for(j=0;j<G.vexnum;++j)
　　　　　　　　　　{
　　　　　　　　　　if(Vexset[j]==vs2)
　　　　　　　　　　　　Vexset[j]=vs1;
　　　　　　　　　　}
　　　　　　}
　　}
　　printf("\n最短路徑長度為：%d\n",sum);
}

Status main()
{
　　AMGraph G;
　　CreateGraph(G);
　　PrintAMGraphArc(G);

　　MiniSpanTree_Prim(G,'A');

　　cout<<"Kruskal:\n";
　　MiniSpanTree_Kruskal(G);
　　system("pause");
　　return OK;
}