Dijkstra和Floyd算法
#include
#include
#include
#define Infinity 999 //最大值
#define Max_Vertex_Num 20 //顶点数最多为20
#define Len sizeof(struct arcNode)
#define gLen sizeof(struct Graph)
#define HIT_Ver_Num 11 //共有11个顶点
#define HIT_Arc_Num 18 //共有18个边
//边节点
struct arcNode{
int adjvex; //该边所指向的顶点位置
struct arcNode *nextArc; //指向下一条边的指针
int value; //边的权值
};
//顶点节点
typedef struct verNode{
char *data; //顶点信息
struct arcNode *firstArc; //指向第一条依附该顶点的边
}verNode,adjList[Max_Vertex_Num];
//图的邻接表存储类型
struct Graph{
int g_arcs[Max_Vertex_Num][Max_Vertex_Num];
adjList vertices; //声明一个存储顶点的数组
int vexNum,arcNum; //vexNum 是顶点数，arcNum 是边数
};
struct Graph * creatGraph()
{
int i,j,a,b;
struct Graph *graph = (struct Graph *)malloc(gLen);
struct arcNode *arc_1 = (struct arcNode *)malloc(Len);//N楼
struct arcNode *arc_2 = (struct arcNode *)malloc(Len);
struct arcNode *arc_3 = (struct arcNode *)malloc(Len);
struct arcNode *arc_4 = (struct arcNode *)malloc(Len);//食堂
struct arcNode *arc_5 = (struct arcNode *)malloc(Len);
struct arcNode *arc_6 = (struct arcNode *)malloc(Len);
struct arcNode *arc_7 = (struct arcNode *)malloc(Len);//教师公寓
struct arcNode *arc_8 = (struct arcNode *)malloc(Len);
struct arcNode *arc_9 = (struct arcNode *)malloc(Len);//M楼
struct arcNode *arc_10 = (struct arcNode *)malloc(Len);
struct arcNode *arc_11 = (struct arcNode *)malloc(Len);
struct arcNode *arc_12 = (struct arcNode *)malloc(Len);//G楼
struct arcNode *arc_13 = (struct arcNode *)malloc(Len);
struct arcNode *arc_14 = (struct arcNode *)malloc(Len);
struct arcNode *arc_15 = (struct arcNode *)malloc(Len);
struct arcNode *arc_16 = (struct arcNode *)malloc(Len);
struct arcNode *arc_17 = (struct arcNode *)malloc(Len);
struct arcNode *arc_18 = (struct arcNode *)malloc(Len);//主楼
struct arcNode *arc_19 = (struct arcNode *)malloc(Len);
struct arcNode *arc_20 = (struct arcNode *)malloc(Len);
struct arcNode *arc_21 = (struct arcNode *)malloc(Len);//H楼
struct arcNode *arc_22 = (struct arcNode *)malloc(Len);
struct arcNode *arc_23 = (struct arcNode *)malloc(Len);
struct arcNode *arc_24 = (struct arcNode *)malloc(Len);//体育场
struct arcNode *arc_25 = (struct arcNode *)malloc(Len);
struct arcNode *arc_26 = (struct arcNode *)malloc(Len);
struct arcNode *arc_27 = (struct arcNode *)malloc(Len);//校训石
struct arcNode *arc_28 = (struct arcNode *)malloc(Len);
struct arcNode *arc_29 = (struct arcNode *)malloc(Len);
struct arcNode *arc_30 = (struct arcNode *)malloc(Len);
struct arcNode *arc_31 = (struct arcNode *)malloc(Len);//研究院
struct arcNode *arc_32 = (struct arcNode *)malloc(Len);
struct arcNode *arc_33 = (struct arcNode *)malloc(Len);
struct arcNode *arc_34 = (struct arcNode *)malloc(Len);//学校正门
struct arcNode *arc_35 = (struct arcNode *)malloc(Len);
struct arcNode *arc_36 = (struct arcNode *)malloc(Len);
char *Data[HIT_Ver_Num] = {"N楼","食堂","教师公寓","M楼","G楼","主楼","H楼","体育场","校训石","研究院","学校正门"};
if(graph==NULL||arc_1==NULL||arc_2==NULL||arc_3==NULL||arc_4==NULL||arc_5==NULL||arc_6==NULL||arc_7==NULL||arc_8==NULL||arc_9==NULL
||arc_10==NULL||arc_11==NULL||arc_12==NULL||arc_13==NULL||arc_14==NULL||arc_15==NULL||arc_16==NULL||arc_17==NULL||arc_18==NULL
||arc_19==NULL||arc_20==NULL||arc_21==NULL||arc_22==NULL||arc_23==NULL||arc_24==NULL||arc_25==NULL||arc_26==NULL||arc_27==NULL
||arc_28==NULL||arc_29==NULL||arc_30==NULL||arc_31==NULL||arc_32==NULL||arc_33==NULL||arc_34==NULL||arc_35==NULL||arc_36==NULL)
{
printf("内存不足\n退出程序");
exit(0);
}
graph->vexNum = HIT_Ver_Num;
graph->arcNum = HIT_Arc_Num;
for(j = 0; j < graph->vexNum; j++)
{
graph->vertices[j].data = Data[j];
graph->vertices[j].firstArc = NULL;
}
arc_1->value = 130;
arc_1->adjvex = 3;
arc_1->nextArc = graph->vertices[0].firstArc;
graph->vertices[0].firstArc = arc_1;
arc_2->value = 140;
arc_2->adjvex = 4;
arc_2->nextArc = graph->vertices[0].firstArc;
graph->vertices[0].firstArc = arc_2;
arc_3->value = 55;
arc_3->adjvex = 1;
arc_3->nextArc = graph->vertices[0].firstArc;
graph->vertices[0].firstArc = arc_3;//End N楼
arc_4->value = 55;
arc_4->adjvex = 0;
arc_4->nextArc = graph->vertices[1].firstArc;
graph->vertices[1].firstArc = arc_4;
arc_5->value = 150;
arc_5->adjvex = 4;
arc_5->nextArc = graph->vertices[1].firstArc;
graph->vertices[1].firstArc = arc_5;
arc_6->value = 110;
arc_6->adjvex = 2;
arc_6->nextArc = graph->vertices[1].firstArc;
graph->vertices[1].firstArc = arc_6;//End 食堂
arc_7->value = 110;
arc_7->adjvex = 1;
arc_7->nextArc = graph->vertices[2].firstArc;
graph->vertices[2].firstArc = arc_7;
arc_8->value = 105;
arc_8->adjvex = 6;
arc_8->nextArc = graph->vertices[2].firstArc;
graph->vertices[2].firstArc = arc_8;//End 教师公寓
arc_9->value = 130;
arc_9->adjvex = 0;
arc_9->nextArc = graph->vertices[3].firstArc;
graph->vertices[3].firstArc = arc_9;
arc_10->value = 40;
arc_10->adjvex = 4;
arc_10->nextArc = graph->vertices[3].firstArc;
graph->vertices[3].firstArc = arc_10;
arc_11->value = 70;
arc_11->adjvex = 7;
arc_11->nextArc = graph->vertices[3].firstArc;
graph->vertices[3].firstArc = arc_11;//End M楼
arc_12->value = 40;
arc_12->adjvex = 3;
arc_12->nextArc = graph->vertices[4].firstArc;
graph->vertices[4].firstArc = arc_12;
arc_13->value = 140;
arc_13->adjvex = 0;
arc_13->nextArc = graph->vertices[4].firstArc;
graph->vertices[4].firstArc = arc_13;
arc_14->value = 150;
arc_14->adjvex = 1;
arc_14->nextArc = graph->vertices[4].firstArc;
graph->vertices[4].firstArc = arc_14;
arc_15->value = 40;
arc_15->adjvex = 5;
arc_15->nextArc = graph->vertices[4].firstArc;
graph->vertices[4].firstArc = arc_15;
arc_16->value = 100;
arc_16->adjvex = 8;
arc_16->nextArc = graph->vertices[4].firstArc;
graph->vertices[4].firstArc = arc_16;
arc_17->value = 65;
arc_17->adjvex = 7;
arc_17->nextArc = graph->vertices[4].firstArc;
graph->vertices[4].firstArc = arc_17;//End G楼
arc_18->value = 40;
arc_18->adjvex = 4;
arc_18->nextArc = graph->vertices[5].firstArc;
graph->vertices[5].firstArc = arc_18;
arc_19->value = 115;
arc_19->adjvex = 6;
arc_19->nextArc = graph->vertices[5].firstArc;
graph->vertices[5].firstArc = arc_19;
arc_20->value = 50;
arc_20->adjvex = 8;
arc_20->nextArc = graph->vertices[5].firstArc;
graph->vertices[5].firstArc = arc_20;//End 主楼
arc_21->value = 105;
arc_21->adjvex = 2;
arc_21->nextArc = graph->vertices[6].firstArc;
graph->vertices[6].firstArc = arc_21;
arc_22->value = 115;
arc_22->adjvex = 5;
arc_22->nextArc = graph->vertices[6].firstArc;
graph->vertices[6].firstArc = arc_22;
arc_23->value = 60;
arc_23->adjvex = 9;
arc_23->nextArc = graph->vertices[6].firstArc;
graph->vertices[6].firstArc = arc_23;//End H楼
arc_24->value = 70;
arc_24->adjvex = 3;
arc_24->nextArc = graph->vertices[7].firstArc;
graph->vertices[7].firstArc = arc_24;
arc_25->value = 65;
arc_25->adjvex = 4;
arc_25->nextArc = graph->vertices[7].firstArc;
graph->vertices[7].firstArc = arc_25;
arc_26->value = 100;
arc_26->adjvex = 10;
arc_26->nextArc = graph->vertices[7].firstArc;
graph->vertices[7].firstArc = arc_26;//End 体育场
arc_27->value = 100;
arc_27->adjvex = 4;
arc_27->nextArc = graph->vertices[8].firstArc;
graph->vertices[8].firstArc = arc_27;
arc_28->value = 50;
arc_28->adjvex = 5;
arc_28->nextArc = graph->vertices[8].firstArc;
graph->vertices[8].firstArc = arc_28;
arc_29->value = 50;
arc_29->adjvex = 9;
arc_29->nextArc = graph->vertices[8].firstArc;
graph->vertices[8].firstArc = arc_29;
arc_30->value = 40;
arc_30->adjvex = 10;
arc_30->nextArc = graph->vertices[8].firstArc;
graph->vertices[8].firstArc = arc_30;//End 校训石
arc_31->value = 50;
arc_31->adjvex = 8;
arc_31->nextArc = graph->vertices[9].firstArc;
graph->vertices[9].firstArc = arc_31;
arc_32->value = 60;
arc_32->adjvex = 6;
arc_32->nextArc = graph->vertices[9].firstArc;
graph->vertices[9].firstArc = arc_32;
arc_33->value = 70;
arc_33->adjvex = 10;
arc_33->nextArc = graph->vertices[9].firstArc;
graph->vertices[9].firstArc = arc_33;//End 研究院
arc_34->value = 100;
arc_34->adjvex = 7;
arc_34->nextArc = graph->vertices[10].firstArc;
graph->vertices[10].firstArc = arc_34;
arc_35->value = 40;
arc_35->adjvex = 8;
arc_35->nextArc = graph->vertices[10].firstArc;
graph->vertices[10].firstArc = arc_35;
arc_36->value = 70;
arc_36->adjvex = 9;
arc_36->nextArc = graph->vertices[10].firstArc;
graph->vertices[10].firstArc = arc_36;//End 学校正门
for(a = 0; a < graph->vexNum; a++) //置为无穷大（999）
{
for(b = 0; b < graph->vexNum; b++)
{
graph->g_arcs[a][b] = Infinity;
}
}
for(i = 0; i < graph->vexNum; i++) //将相应位置置权值
{
while(graph->vertices[i].firstArc != NULL)
{
graph->g_arcs[i][graph->vertices[i].firstArc->adjvex] = graph->vertices[i].firstArc->value;
graph->vertices[i].firstArc = graph->vertices[i].firstArc->nextArc;
}
}
return graph;
}
//单源最短路径(即 Dijkstra算法)
void shortestPath_Dij(struct Graph graph,int v0)
{
int i = 0,v,w,min,pre;
int arrayD[HIT_Ver_Num],arrayP[HIT_Ver_Num];//辅助数组
int arrayFinal[HIT_Ver_Num];//辅助数组
//初始化
for(v = 0; v < graph.vexNum; v++)
{
arrayFinal[v] = 0;
arrayD[v] =graph.g_arcs[v0][v];
if(arrayD[v] < Infinity)
{
arrayP[v] = v0;
}
else
{
arrayP[v] = -1;
}
}
arrayFinal[v0] = 1;
arrayP[v0] = -1;
for(i = 1; i < graph.vexNum; i++)
{
min = Infinity;
//加入具有最小代价的邻居节点
for(w = 0; w < graph.vexNum; w++)
{
if(!arrayFinal[w] && (arrayD[w] < min))
{
v = w;
min = arrayD[w];
}
}
arrayFinal[v] = 1;
//计算加入新的节点后，更新路径使得其产生代价最短
for(w = 0; w < graph.vexNum; w++)
{
if(!arrayFinal[w] && (min + graph.g_arcs[v][w] < arrayD[w]))
{
arrayD[w] = min + graph.g_arcs[v][w];
arrayP[w] = v;
}
}
}
for(i = 0; i < graph.vexNum; i++)
{
if(v0 == i)
printf("目的地与起点重合，权值为零\n\n");
else
{
printf("权值为：%d\n",arrayD[i]);
printf("%s",graph.vertices[i].data);
pre = arrayP[i];
while(pre != -1)
{
printf(" <-- %s",graph.vertices[pre].data);
pre = arrayP[pre];
}
printf("\n\n");
}
}
}
void shortestPath_Floyd(struct Graph graph,int v1,int v2)
{
int i,j,k,temp;
int arrayPath[HIT_Ver_Num][HIT_Ver_Num],arrayDis[HIT_Ver_Num][HIT_Ver_Num];
//初始化
for(i = 0; i < graph.vexNum; i++)
{
for(j = 0; j < graph.vexNum; j++)
{
if(graph.g_arcs[i][j] < Infinity)
arrayPath[i][j] = j;
else
arrayPath[i][j] = -1;
arrayDis[i][j] = graph.g_arcs[i][j];
}
}
for(k = 0; k < graph.vexNum; k++)//对所有顶点进行试探
{
for(i = 0; i < graph.vexNum; i++)
{
for(j = 0; j < graph.vexNum; j++)
{
if(arrayDis[i][j] > arrayDis[i][k] + arrayDis[k][j])
{
arrayDis[i][j] = arrayDis[i][k] + arrayDis[k][j];//取较小者
arrayPath[i][j] = arrayPath[i][k];//改Vi的后继
}
}
}
}
printf("从 %s 到 %s 的最短距离为：%d\n",graph.vertices[v1].data,graph.vertices[v2].data,arrayDis[v1][v2]);
printf("最短路径为：\t");
temp = arrayPath[v1][v2];
printf("%s --> ",graph.vertices[v1].data);//输出V1
while(temp != v2)//temp不等于路径终点v2时
{
printf("%s --> ",graph.vertices[temp].data);//输出
temp = arrayPath[temp][v2];//求路径上下一顶点
}
printf("%s.",graph.vertices[v2].data);//输出V2
printf("\n");
}
int main()
{
int b,c,count = 0;
int num,i,a,i_2,i_3;
char *nodeName_1 = (char*)malloc(10);//必须得用malloc函数申请空间
char *nodeName_2 = (char*)malloc(10);//必须得用malloc函数申请空间
char *nodeName_3 = (char*)malloc(10);//必须得用malloc函数申请空间
struct Graph *graph;
graph = creatGraph(); //生成图
for(b=0;bvexNum;b++)
{
for(c = 0;cvexNum;c ++)
{
printf("%d\t",graph->g_arcs[b][c]);
}
printf("\n");
}
printf("请按提示进行操作:\n");
printf("1、输入任意一个节点的名称，显示它到各个节点的最短路径及最短距离。\n");
printf("2、输入任意两个节点的名称，显示两点间最短路径和最短距离。\n");
printf("请输入 1 或 2 进行查询。\n");
scanf("%d",&num);
switch(num)
{
case 1:
for(a = 0;avexNum;a++)
{
printf("%s ",graph->vertices[a].data);
}
printf("\n");
printf("请输入节点名称：\n");
scanf("%s",nodeName_1);
for(i = 0; i < graph->vexNum; i++)
{
if(strcmp(nodeName_1,graph->vertices[i].data) != 0)
{
count++;
}
if(0 == strcmp(nodeName_1,graph->vertices[i].data))
{
shortestPath_Dij(*graph,i);
}
}
if(graph->vexNum == count)
{
printf("输入名称有误！退出程序！");
exit(0);
}
break;
case 2:
for(a = 0;avexNum;a++)
{
printf("%s ",graph->vertices[a].data);
}
printf("\n");
printf("请分别输入第一个节点名称：\n");
scanf("%s",nodeName_2);
printf("请分别输入第二个节点名称：\n");
scanf("%s",nodeName_3);
for(i = 0; i < graph->vexNum; i++)
{
if(0 == strcmp(nodeName_2,graph->vertices[i].data))
{
i_2 = i;
}
if(0 == strcmp(nodeName_3,graph->vertices[i].data))
{
i_3 = i;
}
}
if(i_2 == i_3)
{
printf("输入的起点和终点重合，退出程序！");
exit(0);
}
shortestPath_Floyd(*graph,i_2,i_3);
break;
default:
printf("输入有误！退出程序！");
exit(0);
break;
}
return 0;
}
实验结果：
Dijkstra和Floyd算法的更多相关文章
- 算法学习笔记（三） 最短路 Dijkstra 和 Floyd 算法
图论中一个经典问题就是求最短路.最为基础和最为经典的算法莫过于 Dijkstra 和 Floyd 算法,一个是贪心算法,一个是动态规划.这也是算法中的两大经典代表.用一个简单图在纸上一步一步演算,也是 ...
- Dijkstra与Floyd算法
1. Dijkstra算法 1.1 定义概览 Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法,用于计算一个节点到其他所有节点的最短路径.主要特点是以起始点为中心向外层层扩展,直到扩展到终点 ...
- Dijkstra and Floyd算法
Dijkstra算法 算法思想:设G=(V,E)是一个带权有向图,把图中顶点集合V分成两组,第一组为已求出最短路径的顶点集合(用S表示,初始时S中只有一个源点,以后每求得一条最短路径 , 就将加入到集 ...
- 图的最短路径——dijkstra算法和Floyd算法
dijkstra算法 求某一顶点到其它各个顶点的最短路径:已知某一顶点v0,求它顶点到其它顶点的最短路径,该算法按照最短路径递增的顺序产生一点到其余各顶点的所有最短路径. 对于图G={V,{E}};将 ...
- (最短路径算法整理)dijkstra、floyd、bellman-ford、spfa算法模板的整理与介绍
这一篇博客以一些OJ上的题目为载体.整理一下最短路径算法.会陆续的更新... 一.多源最短路算法--floyd算法 floyd算法主要用于求随意两点间的最短路径.也成最短最短路径问题. 核心代码: / ...
- 最短路径—Dijkstra算法和Floyd算法
原文链接:http://www.cnblogs.com/biyeymyhjob/archive/2012/07/31/2615833.html 最后边附有我根据文中Dijkstra算法的描述使用jav ...
- 最短路径---Dijkstra/Floyd算法
1.Dijkstra算法基础: 算法过程比prim算法稍微多一点步骤,但思想确实巧妙也是贪心,目的是求某个源点到目的点的最短距离,总的来说dijkstra也就是求某个源点到目的点的最短路,求解的过程也 ...
- 最短路径—大话Dijkstra算法和Floyd算法
Dijkstra算法 算法描述 1)算法思想:设G=(V,E)是一个带权有向图,把图中顶点集合V分成两组,第一组为已求出最短路径的顶点集合(用S表示,初始时S中只有一个源点,以后每求得一条最短路径 , ...
- Dijkstra 算法、Kruskal 算法、Prim算法、floyd算法
1.dijkstra算法 算最短路径的,算法解决的是有向图中单个源点到其他顶点的最短路径问题. 初始化n*n的数组. 2.kruskal算法 算最小生成树的,按权值加入 3.Prim算法 类似dijk ...
随机推荐
- 【HDU - 4340】Capturing a country（树形DP）
BUPT2017 wintertraining(15) #8A 题意 n(<100)个城市组成的树.A攻击i城市需要a[i]代价,B需要b[i].如果一个城市的邻居被A攻击了,那么A攻击它只要A ...
- python学习日记（装饰器的补充）
如何返回被装饰函数的函数名及注释? 问题及实现 先看典型的装饰器: def wrapper(f):#装饰器函数,f是被装饰函数 def inner(*args,**kwargs): '''执行函数之前 ...
- Nagios 使用 NSClient++ 监控Windows Server
在被监控的Windows server 主机上安装NSClinet++下载地址:https://www.nsclient.org/download/32bit:http://files.nsclien ...
- PKUWC2019 凉凉记
请配合 BGM 食用. 菜就是菜,说什么都是借口. Day 0 前一天先到纪中报道,高铁上打了一会单机膈膜,然后又打了一遍 \(FFT\) 板子,就到了中山. 到了后,发现气温骤然升高,马上 脱 换裤 ...
- Angular、React.js 和Node.js到底选谁?
为了工作,程序员选择正确的框架和库来构建应用程序是至关重要的,这也就是为什么Angular和React之间有着太多的争议.Node.js的出现,让这场战争变得更加复杂,虽然有选择权通常是一件很棒的事情 ...
- 小程序-camera
camera 使用这个组件使用手机的拍摄功能.实现如下操作 打开拍摄画面,在手机上半屏显示拍摄取景,下面有一个拍摄按钮.点击后,取景器位置显示拍摄画面,下面显示确定取消按钮. 确定后,下方的预览图片列 ...
- 只用200行Go代码写一个自己的区块链！
Coral Health · 大约23小时之前 · 220 次点击 · 预计阅读时间 7 分钟 · 不到1分钟之前 开始浏览 区块链是目前最热门的话题,广大读者都听说过比特币,或许还有智能合约,相信大 ...
- C++常见函数使用
备注:总结C++中一些常见函数的使用,提高工作效率 数组的拼接: //报文头的前6B固定 DRV_UCHAR pkt_info_head[PALIVE_TO_NP_LEN] = {0x70, 0xff ...
- Python之推导式、生成器表达式
l = [i for i in range(10)] print(l) l1 = ['选项%s'%i for i in range(10)] print(l1) 1.把列表解析的[]换成()得到的就是 ...
- 将Excel导出为SQL语句
需求说明:公司做项目前进行需求分析,确定表结构后需要建表,如果照着表格去敲,那就太麻烦了,所以想到了自动生成SQL语句. 思路大概就是:解析Excel,拼接SQL语句,输出SQL文件. 第三方jar包 ...