最小生成树（prim&keluskal）最短路径（dijistra）

#include <stdio.h>
#include <stdlib.h>

#define MAX_VEXNUM 20
#define MAX_ACE 99

/*-------------------------------------------------
图结构定义
char vex[MAX_VEXNUM]:存放各个顶点
int adjmatrix[MAX_VEXNUM][MAX_VEXNUM]:邻接矩阵表示边
int vexnum:顶点数
int acenum:边数
---------------------------------------------------*/
typedef struct GMap
{
char vexs[MAX_VEXNUM];
int adjmatrix[MAX_VEXNUM][MAX_VEXNUM];
int vexnum;
int acenum;
};

typedef struct closet
{
int lowcost;
char adjvex;
}c;
c close[MAX_VEXNUM];

/*-----------------------------------------------
查找图中某一顶点对应的在数组中的索引
G:图
u:某一顶点char型
返回值：如果查找成果返回索引值，否则，返回-1；
-----------------------------------------------*/
int LocateVex(GMap G, char u)
{
for ( int i = 0; i < G.vexnum; i++)
{
if ( G.vexs[i] == u )
{
return i;
}
}

return -1;
}

/*--------------------------------------------------
初始化有向图
g：图指针
--------------------------------------------------*/
void init_graph(GMap *g)
{
int i = 0, j = 0;
g->vexnum = 5;

for( i = 0; i < 5; i++)
for( j = 0; j < 5; j++)
g->adjmatrix[i][j] = MAX_ACE;

g->adjmatrix[0][1] = 1;
g->adjmatrix[0][3] = 3;
g->adjmatrix[0][4] = 7;
g->adjmatrix[1][2] = 2;
g->adjmatrix[2][3] = 2;
g->adjmatrix[2][4] = 2;
g->adjmatrix[3][4] = 5;
g->adjmatrix[3][2] = 3;
g->adjmatrix[3][1] = 1;
g->vexs[0] = 'a';
g->vexs[1] = 'b';
g->vexs[2] = 'c';
g->vexs[3] = 'd';
g->vexs[4] = 'e';
}

/*-----------------------------------------------
初始化无向图
g：图指针
------------------------------------------------*/
void inimap(GMap* g)
{
g->vexnum = 5;
g->acenum = 7;
int i, j;

char array[] = {'a', 'b', 'c', 'd', 'e'};
for ( i = 0; i < g->vexnum; i++ )
{
g->vexs[i] = array[i];
}

for ( i = 0; i < g->vexnum; i++ )
{
for ( j = 0; j < g->vexnum; j++)
{
g->adjmatrix[i][j] = MAX_ACE;
}
}

g->adjmatrix[0][1] = 3;
g->adjmatrix[1][0] = 3;
g->adjmatrix[0][2] = 1;
g->adjmatrix[2][0] = 1;
g->adjmatrix[1][2] = 7;
g->adjmatrix[2][1] = 7;
g->adjmatrix[2][3] = 2;
g->adjmatrix[3][2] = 2;
g->adjmatrix[2][4] = 8;
g->adjmatrix[4][2] = 8;
g->adjmatrix[1][4] = 4;
g->adjmatrix[4][1] = 4;
g->adjmatrix[3][4] = 7;
g->adjmatrix[4][3] = 7;

}

/*
void CreateMap(GMap* g)
{
int i, j;
char c;
printf("input the number of vexs and aces:/n");
scanf("%d", &g->vexnum);
scanf("%d", &g->acenum);

printf("input %d vexs:/n", g->vexnum);
for ( i = 0; i < g->vexnum; i++ )
{
scanf("%c", &c);
g->vexs[i] = c;
}

for ( i = 0; i < g->vexnum; i++ )
{
for ( j = 0; j < g->vexnum; j++)
{
g->adjmatrix[i][j] = MAX_ACE;
}
}

for ( int t = 0; t < g->vexnum; t++)
{
printf("%c ", g->vexs[t]);

}
// g.adjmatrix[1][3] = 3;
// g.adjmatrix[3][1] = 3;

char vex1, vex2;
int weight;
printf("input %d aces:(vex1 vex2 weight):/n", g->acenum );
for ( int x = 0; x < g->acenum; x++ )
{
scanf("%c", &vex1);
scanf("%c", &vex2);
scanf("%d", &weight);
i = LocateVex(g, vex1);
j = LocateVex(g, vex2);
g->adjmatrix[i][j] = weight;
g->adjmatrix[j][i] = weight;

i = 0;
j = 0;
while ( vex1 != g.vexs[i])
{
i++;
}

while ( vex2 != g.vexs[j] )
{
j++;
}

g.adjmatrix[i][j] = weight;
g.adjmatrix[j][i] = weight;

}

}
*/

/*----------------------------------------------------------
查找最小边值
g：图
----------------------------------------------------------*/
int minimum(GMap g)
{
int min = MAX_ACE;
int i = 0;
int result;

while ( close[i].adjvex != '/0' )
{
if ( min > close[i].lowcost && close[i].lowcost != 0 )
{
min = close[i].lowcost;
result = i;
}
i++;
}
return result;
}

/*----------------------------------------------------------
prim最小生成树算法
GMap g:图
char u:从顶点u出发生成最小生成树
-----------------------------------------------------------*/
void prim(GMap g, char u)
{
int i, j;
int k;
k = LocateVex( g, u );
for ( i = 0; i < g.vexnum; i++ )
{
if ( k != i)
{
close[i].adjvex = g.vexs[k];
close[i].lowcost = g.adjmatrix[k][i];
}
}
close[i].adjvex = '/0';
close[i].lowcost = MAX_ACE;
close[k].adjvex = u;
close[k].lowcost = 0;

for ( k = 1; k < g.vexnum; k++)
{
int min = minimum( g );
printf("%c--%c/n", close[min].adjvex, g.vexs[min]);
close[min].lowcost = 0;

for ( i = 0; i < g.vexnum; i++ )
{
if ( close[i].lowcost > g.adjmatrix[min][i])
{
close[i].lowcost = g.adjmatrix[min][i];
close[i].adjvex = g.vexs[min];
}
}
}
}

/*-----------------------------------------------------
keluskal最小生成树算法
GMap g:图
------------------------------------------------------*/
void keluskal(GMap g)
{
int i, j;
int a, b;
int k = 0;
int min = MAX_ACE;

//set[]，开始时，各个顶点自己各成一个集合
int set[MAX_VEXNUM];
for ( i = 0; i < g.vexnum; i++)
{
set[i] = i;
}

while ( k < g.vexnum - 1 )
{
for ( i = 0; i < g.vexnum; i++ )
{
for ( j = i; j < g.vexnum; j++ )
{
if ( min > g.adjmatrix[i][j] )
{
min = g.adjmatrix[i][j];
a = i;
b = j;
}
}
}
int temp = g.adjmatrix[a][b];
min = g.adjmatrix[a][b] = MAX_ACE;

if ( set[a] != set[b] )
{
printf("%c--%c %d/n", g.vexs[a], g.vexs[b], temp);
k++;
for ( i = 0; i < g.vexnum; i++ )
{
if ( set[i] == set[b] )
{
set[i] = set[a];
}
}
}

}
}

/*-------------------------------------------
dijkstra算法：有向图最短路径生成算法
依次打印从顶点vex_index到其他顶点的最短路径
g：图
vex_index：顶点索引值
-------------------------------------------*/
void shortpath_dijkstra(GMap g, int vex_index)
{
int i, j;

int dist[MAX_VEXNUM];
int cost[MAX_VEXNUM][MAX_VEXNUM];
int set[MAX_VEXNUM];
int path[MAX_VEXNUM];

for ( i = 0; i < g.vexnum; i++ )
{
set[i] = 0;
}

for ( i = 0; i < g.vexnum; i++ )
{
for ( j = 0; j < g.vexnum; j++ )
{
cost[i][j] = g.adjmatrix[i][j];
}
}

for ( j = 0; j < g.vexnum; j++ )
{
dist[j] = g.adjmatrix[vex_index][j];
if ( dist[j] < MAX_ACE && dist[j] > 0 )
{
path[j] = vex_index;
}
}

set[vex_index] = 1;

int min;
int u;
for ( i = 0; i < g.vexnum; i++ )
{
min = MAX_ACE;
for ( j = 0; j < g.vexnum; j++ )
{
if ( min > dist[j] && set[j] != 1)
{
min = dist[j];
u = j;
}
}
set[u] = 1;

for ( j = 0; j < g.vexnum; j++ )
{
if ( dist[u] + cost[u][j] < dist[j] && set[j] != 1)
{
dist[j] = dist[u] + cost[u][j];
path[j] = u;
}
}
}

for ( i = 0; i < g.vexnum; i++)
{
u = i;
if ( set[u] == 1 )
{
while ( u != vex_index )
{
printf("%c<--", g.vexs[u]);
u = path[u];
}
printf("%c/n", g.vexs[u]);

}
else
{
printf("no path/n");
}
}
}

void main()
{
GMap g;
inimap(&g);
for ( int i = 0; i < g.vexnum; i++)
{
for ( int j = 0; j < g.vexnum; j++)
{
printf("%d ", g.adjmatrix[i][j]);
}
printf("/n");
}
/* inimap(&g);
for ( int i = 0; i < g.vexnum; i++)
{
for ( int j = 0; j <g.vexnum; j++)
{
printf("%d ", g.adjmatrix[i][j]);
}
printf("/n");
}
printf("/n");
printf("vexnum = %d/n", g.vexnum);
printf("acenum = %d/n", g.acenum);

for ( int k = 0; k < g.vexnum; k++ )
{
char c = g.vexs[k];
printf( "%c", c);
}
printf("/n");
*/
keluskal(g);
printf("/n");

prim(g, 'e');

init_graph(&g);
shortpath_dijkstra(g, 0);

}