目录
1.最小生成树Kruskakl(克鲁斯卡尔算法)
//算法6.9 克鲁斯卡尔算法
#include <iostream>
using namespace std;
typedef char VerTexType; //假设顶点的数据类型为字符型
typedef int ArcType;
#define MVNum 100 //最大顶点数
#define MaxInt 32767 //表示极大值,即∞
//----------------图的邻接矩阵---------------------
typedef struct{
VerTexType vexs[MVNum]; //顶点表
ArcType arcs[MVNum][MVNum]; //邻接矩阵
int vexnum,arcnum; //图的当前点数和边数
}AMGraph;
//辅助数组Edges的定义
struct{
VerTexType Head; //边的始点
VerTexType Tail; //边的终点
ArcType lowcost; //边上的权值
}Edge[(MVNum * (MVNum - 1)) / 2];
int Vexset[MVNum]; //辅助数组Vexset的定义
int LocateVex(AMGraph G , VerTexType v){
//确定点v在G中的位置
for(int i = 0; i < G.vexnum; ++i)
if(G.vexs[i] == v)
return i;
return -1;
}//LocateVex
void CreateUDN(AMGraph &G){
//采用邻接矩阵表示法,创建无向网G
int i , j , k;
cout <<"请输入总顶点数,总边数,以空格隔开:";
cin >> G.vexnum >> G.arcnum; //输入总顶点数,总边数
cout << endl;
cout << "输入点的名称,如a" << endl;
for(i = 0; i < G.vexnum; ++i){
cout << "请输入第" << (i+1) << "个点的名称:";
cin >> G.vexs[i]; //依次输入点的信息
}
cout << endl;
for(i = 0; i < G.vexnum; ++i) //初始化邻接矩阵,边的权值均置为极大值MaxInt
for(j = 0; j < G.vexnum; ++j)
G.arcs[i][j] = MaxInt;
cout << "输入边依附的顶点及权值,如a b 6" << endl;
for(k = 0; k < G.arcnum;++k){ //构造邻接矩阵
VerTexType v1 , v2;
ArcType w;
cout << "请输入第" << (k + 1) << "条边依附的顶点及权值:";
cin >> v1 >> v2 >> w; //输入一条边依附的顶点及权值
i = LocateVex(G, v1); j = LocateVex(G, v2); //确定v1和v2在G中的位置,即顶点数组的下标
G.arcs[i][j] = w; //边<v1, v2>的权值置为w
G.arcs[j][i] = G.arcs[i][j]; //置<v1, v2>的对称边<v2, v1>的权值为w
Edge[k].lowcost = w;
Edge[k].Head = v1;
Edge[k].Tail = v2;
}//for
}//CreateUDN
//----------冒泡排序-------------------
void Sort(AMGraph G){
int m = G.arcnum - 2;
int flag = 1;
while((m > 0) && flag == 1){
flag = 0;
for(int j = 0 ; j <= m ; j++){
if(Edge[j].lowcost > Edge[j+ 1].lowcost){
flag = 1;
VerTexType temp_Head = Edge[j].Head;
Edge[j].Head = Edge[j+ 1].Head;
Edge[j + 1].Head = temp_Head;
VerTexType temp_Tail = Edge[j].Tail;
Edge[j].Tail = Edge[j+ 1].Tail;
Edge[j + 1].Tail = temp_Tail;
ArcType temp_lowcost = Edge[j].lowcost;
Edge[j].lowcost = Edge[j+ 1].lowcost;
Edge[j + 1].lowcost = temp_lowcost;
}//if
}//for
--m;
}//while
}//Sort
void MiniSpanTree_Kruskal(AMGraph G){
//无向网G以邻接矩阵形式存储,构造G的最小生成树T,输出T的各条边
int i , j , v1 , v2 , vs1 , vs2;
Sort(G); //将数组Edge中的元素按权值从小到大排序
for(i = 0; i < G.vexnum; ++i) //辅助数组,表示各顶点自成一个连通分量
Vexset[i] = i;
for(i = 0; i < G.arcnum; ++i){
//依次查看排好序的数组Edge中的边是否在同一连通分量上
v1 =LocateVex(G, Edge[i].Head); //v1为边的始点Head的下标
v2 =LocateVex(G, Edge[i].Tail); //v2为边的终点Tail的下标
vs1 = Vexset[v1]; //获取边Edge[i]的始点所在的连通分量vs1
vs2 = Vexset[v2]; //获取边Edge[i]的终点所在的连通分量vs2
if(vs1 != vs2){ //边的两个顶点分属不同的连通分量
cout << Edge[i].Head << "-->" << Edge[i].Tail << endl; //输出此边
for(j = 0; j < G.vexnum; ++j) //合并vs1和vs2两个分量,即两个集合统一编号
if(Vexset[j] == vs2) Vexset[j] = vs1; //集合编号为vs2的都改为vs1
}//if
}//for
}//MiniSpanTree_Kruskal
void main(){
cout << "************算法6.9 克鲁斯卡尔算法**************" << endl << endl;
AMGraph G;
CreateUDN(G);
cout <<endl;
cout << "*****无向网G创建完成!*****" << endl;
cout <<endl;
MiniSpanTree_Kruskal(G);
}///main
2.最短路径Floyed(弗洛伊德算法)
//算法6.11 弗洛伊德算法
#include <iostream>
using namespace std;
#define MaxInt 32767 //表示极大值,即∞
#define MVNum 100 //最大顶点数
typedef char VerTexType; //假设顶点的数据类型为字符型
typedef int ArcType; //假设边的权值类型为整型
int Path[MVNum][MVNum]; //最短路径上顶点vj的前一顶点的序号
int D[MVNum][MVNum]; //记录顶点vi和vj之间的最短路径长度
//------------图的邻接矩阵---------------
typedef struct{
VerTexType vexs[MVNum]; //顶点表
ArcType arcs[MVNum][MVNum]; //邻接矩阵
int vexnum,arcnum; //图的当前点数和边数
}AMGraph;
int LocateVex(AMGraph G , VerTexType v){
//确定点v在G中的位置
for(int i = 0; i < G.vexnum; ++i)
if(G.vexs[i] == v)
return i;
return -1;
}//LocateVex
void CreateUDN(AMGraph &G){
//采用邻接矩阵表示法,创建有向网G
int i , j , k;
cout <<"请输入总顶点数,总边数,以空格隔开:";
cin >> G.vexnum >> G.arcnum; //输入总顶点数,总边数
cout << endl;
cout << "输入点的名称,如a" << endl;
for(i = 0; i < G.vexnum; ++i){
cout << "请输入第" << (i+1) << "个点的名称:";
cin >> G.vexs[i]; //依次输入点的信息
}
cout << endl;
for(i = 0; i < G.vexnum; ++i){ //初始化邻接矩阵,边的权值均置为极大值MaxInt
for(j = 0; j < G.vexnum; ++j){
if(j != i)
G.arcs[i][j] = MaxInt;
else
G.arcs[i][j] = 0;
}//for
}//for
cout << "输入边依附的顶点及权值,如a b 3" << endl;
for(k = 0; k < G.arcnum;++k){ //构造邻接矩阵
VerTexType v1 , v2;
ArcType w;
cout << "请输入第" << (k + 1) << "条边依附的顶点及权值:";
cin >> v1 >> v2 >> w; //输入一条边依附的顶点及权值
i = LocateVex(G, v1); j = LocateVex(G, v2); //确定v1和v2在G中的位置,即顶点数组的下标
G.arcs[i][j] = w; //边<v1, v2>的权值置为w
}//for
}//CreateUDN
void ShortestPath_Floyed(AMGraph G){
//用Floyd算法求有向网G中各对顶点i和j之间的最短路径
int i , j , k ;
for (i = 0; i < G.vexnum; ++i) //各对结点之间初始已知路径及距离
for(j = 0; j < G.vexnum; ++j){
D[i][j] = G.arcs[i][j];
if(D[i][j] < MaxInt && i != j) Path[i][j]=i; //如果i和j之间有弧,则将j的前驱置为i
else Path [i][j] = -1; //如果i和j之间无弧,则将j的前驱置为-1
}//for
for(k = 0; k < G.vexnum; ++k)
for(i = 0; i < G.vexnum; ++i)
for(j = 0; j < G.vexnum; ++j)
if(D[i][k] + D[k][j] < D[i][j]){ //从i经k到j的一条路径更短
D[i][j] = D[i][k]+D[k][j]; //更新D[i][j]
Path[i][j] = Path[k][j]; //更改j的前驱为k
}//if
}//ShortestPath_Floyed
void DisplayPath(AMGraph G , int begin ,int temp ){
//显示最短路径
if(Path[begin][temp] != -1){
DisplayPath(G , begin ,Path[begin][temp]);
cout << G.vexs[Path[begin][temp]] << "-->";
}
}//DisplayPath
void main(){
cout << "************算法6.11 弗洛伊德算法**************" << endl << endl;
AMGraph G;
char start , destination;
int num_start , num_destination;
CreateUDN(G);
cout <<endl;
cout << "有向网G创建完成!" << endl;
ShortestPath_Floyed(G);
cout << "请依次输入路径的起点与终点的名称:";
cin >> start >> destination;
num_start = LocateVex(G , start);
num_destination = LocateVex(G , destination);
DisplayPath(G , num_start , num_destination);
cout << G.vexs[num_destination] << endl;
cout << "最短路径的长度为:" << D[num_start][num_destination] << endl;
cout <<endl;
}//main
3.最小生成树Prim(普里姆算法)
//算法6.8 普里姆算法
#include <iostream>
using namespace std;
typedef char VerTexType;
typedef int ArcType;
#define MVNum 100
#define MaxInt 32767 //表示极大值,即∞
//辅助数组的定义,用来记录从顶点集U到V-U的权值最小的边
struct{
VerTexType adjvex; //最小边在U中的那个顶点
ArcType lowcost; //最小边上的权值
}closedge[MVNum];
//- - - - -图的邻接表存储表示- - - - -
typedef char VerTexType; //假设顶点的数据类型为字符型
typedef int ArcType; //假设边的权值类型为整型
typedef struct{
VerTexType vexs[MVNum]; //顶点表
ArcType arcs[MVNum][MVNum]; //邻接矩阵
int vexnum,arcnum; //图的当前点数和边数
}AMGraph;
int LocateVex(AMGraph G , VerTexType v){
//确定点v在G中的位置
for(int i = 0; i < G.vexnum; ++i)
if(G.vexs[i] == v)
return i;
return -1;
}//LocateVex
void CreateUDN(AMGraph &G){
//采用邻接矩阵表示法,创建无向网G
int i , j , k;
cout <<"请输入总顶点数,总边数,以空格隔开:";
cin >> G.vexnum >> G.arcnum; //输入总顶点数,总边数
cout << endl;
cout << "输入点的名称,如a" << endl;
for(i = 0; i < G.vexnum; ++i){
cout << "请输入第" << (i+1) << "个点的名称:";
cin >> G.vexs[i]; //依次输入点的信息
}
cout << endl;
for(i = 0; i < G.vexnum; ++i) //初始化邻接矩阵,边的权值均置为极大值MaxInt
for(j = 0; j < G.vexnum; ++j)
G.arcs[i][j] = MaxInt;
cout << "输入边依附的顶点及权值,如a b 5" << endl;
for(k = 0; k < G.arcnum;++k){ //构造邻接矩阵
VerTexType v1 , v2;
ArcType w;
cout << "请输入第" << (k + 1) << "条边依附的顶点及权值:";
cin >> v1 >> v2 >> w; //输入一条边依附的顶点及权值
i = LocateVex(G, v1); j = LocateVex(G, v2); //确定v1和v2在G中的位置,即顶点数组的下标
G.arcs[i][j] = w; //边<v1, v2>的权值置为w
G.arcs[j][i] = G.arcs[i][j]; //置<v1, v2>的对称边<v2, v1>的权值为w
}//for
}//CreateUDN
int Min(AMGraph G){
//返回权值最小的点
int i;
int index = -1;
int min = MaxInt;
for(i = 0 ; i < G.vexnum ; ++i){
if(min > closedge[i].lowcost && closedge[i].lowcost != 0){
min = closedge[i].lowcost;
index = i;
}
}//for
return index;
}//Min
void MiniSpanTree_Prim(AMGraph G, VerTexType u){
//无向网G以邻接矩阵形式存储,从顶点u出发构造G的最小生成树T,输出T的各条边
int k , j , i;
VerTexType u0 , v0;
k =LocateVex(G, u); //k为顶点u的下标
for(j = 0; j < G.vexnum; ++j){ //对V-U的每一个顶点vi,初始化closedge[i]
if(j != k){
closedge[j].adjvex = u;
closedge[j].lowcost = G.arcs[k][j]; //{adjvex, lowcost}
}//if
}//for
closedge[k].lowcost = 0; //初始,U = {u}
for(i = 1; i < G.vexnum; ++i){ //选择其余n-1个顶点,生成n-1条边(n= G.vexnum)
k = Min(G);
//求出T的下一个结点:第k个顶点,closedge[k]中存有当前最小边
u0 = closedge[k].adjvex; //u0为最小边的一个顶点,u0∈U
v0 = G.vexs[k]; //v0为最小边的另一个顶点,v0∈V-U
cout << "边 " <<u0 << "--->" << v0 << endl; //输出当前的最小边(u0, v0)
closedge[k].lowcost = 0; //第k个顶点并入U集
for(j = 0; j < G.vexnum; ++j)
if(G.arcs[k][j] < closedge[j].lowcost){ //新顶点并入U后重新选择最小边
closedge[j].adjvex = G.vexs[k];
closedge[j].lowcost = G.arcs[k][j];
}//if
}//for
}//MiniSpanTree_Prim
int main(){
cout << "************算法6.8 普里姆算法**************" << endl << endl;
AMGraph G;
CreateUDN(G);
cout << endl;
cout << "无向图G创建完成!" << endl;
cout <<endl;
cout << "******利用普里姆算法构造最小生成树结果:******" << endl;
MiniSpanTree_Prim(G , 'a');
cout <<endl;
return 0;
}//main