广度优先遍历
广度优先遍历BreadthFirstSearch，也称广度优先搜索，简称BFS。
可以利用队列实现堆图的广度优先遍历。
下面代码是邻接矩阵代码实现，只有部分代码
#include <stdio.h>
void BFETraverse(MGraph G)
{
int i,j;
Queue Q;
for(i = 0; i < G.numVertexse; i++)
{
visited[i] = FALSE;
}
initQueue( &Q);
for(i =0; i< G.numVertexse; i++)
{
if(!visited[i]
{
printf("%c ",G.vex[i]);
visited[i] = TRUE;
EnQueue(& Q, i);
while(! QueueEmpty(Q))
{
DeQueue( &Q, &i);
for( j =0; j < G.numVertexse ; j++)
{
if(G.art[i][j] == 1 && !visited[j])
{
printf("%c ",G.vex[j]);
visited[j] = TRUE;
EnQueue(& Q, j);
}
}
}
}
}
}
带权最小生成树-- 普里姆算法
如下图，生成了一棵树，但是成本比较高。
采用上述方法，成本比较高，现在来看方案二和方案三的生成树
下面讲普里姆算法的思路与分析
生成了邻接矩阵，数值代表权值，∞代表不连接，0代表自己。
普里姆算法：以某顶点为起点，逐步找各个顶点上最小权值的边来构建最小生成树的。
下面是代码实现
void MiniSpanTree_Prim(MGraph G)
{
int min,i,j,k;
int adjvex[MAXVEX]; //存放相关顶点的下标，0代表没有相连，1代表有联系
int lowcost[MAXVEX]; //存放相关顶点间边的权值
lowcost[0] = 0; //V0作为最小生成树的根开始遍历，权值为0
adjvex[0] = 0; //V0第一个加入
//初始化操作
for( i = 1; i<G.numVertexes;i++)
{
lowcost[i] = G.arc[0][i]; //将邻接矩阵第0行所有权值先加入数组
adjvex[i] = 0; //初始化全部纤维V0的下标
}
//真正构造最小生成树的过程
for( i = 1; i< G;i++)
{
min = INFINITY; //初始化最小权值为65535等不可能数值
j= 1;
k = 0;
//遍历全部顶点
while(j < G.numVertexes)
{
//找出来lowcost数组已存储的最小权值
if(lowcost[j] !=0 && lowcost[j] < min)
{
min = lowcost[j];
k = j; //将发现的最小权值的下标存入k，以待使用
}
j++;
}
//打印当前顶点边中权值最小的边
printf("(%d,%d)",adjvex[k],k);
lowcost[k] = 0; //将当前的顶点权值设置为0，表示此顶点已经完成任务，进行下一个顶点的遍历
//邻接矩阵k行逐个遍历全部顶点
for(j = ; j< G.numVertexes ;j++)
{
if(lowcost[j] != 0 && G.arc[k][j] < lowcost[j] )
{
lowcost[j] = G.arc[k][j];
adjvex[j] = k;
}
}
}
}
带权最小生成树-- 克鲁斯卡尔算法
考虑出发点：为了使生成树上的权值之和达到最小，则应使生成树中每一条边的权值尽可能地小。
克鲁斯卡尔算法：从边出发，直接去找最小权值的边构建生成树。
代码实现
int Find(int *parent, int f)
{
while(parent(f) > 0)
{
f = parent(f);
}
return f;
}
//Kruskal 算法生成最小生成树
void MiniSpanTree_Kruskal(MGraph G)
{
int i, n ,m;
Edge edges[MAGEDGE]; //定义边集数组
int parent[MAXVEX]; //定义parent数组用来判断边与边是否形成回路
for(i = 0; i< G.numVertexes; i++)
{
parent[i] = 0;
}
for(i = 0;i <G.numEdges ; i++)
{
n = Find(parent , edges[i].begin); // 4 2 0 1 5 3 8 6 6 6 7
n = Find(parent, edges[i].end); // 7 8 1 5 8 7 6 6 6 7 7
if( n!= m) //如果n==m，则形成环路，不满足
{
parent[n] = m;//将此边的结尾顶点放入下标为起点的parent数组中，表示此顶点已经在生成树集合中
printf("(%d, %d) %d",edges[i].begin ,edges[i].end,edges[i].weight);
}
}
}
最短路径之迪杰斯特拉算法
最短路径：
- 在网图中，两顶点经过的边上权值之和最少的路径。
- 非网图是两顶点之间经过的边数最少的路径。
路径开始的第一个顶点称为源点，最后一个顶点称为终点。
迪杰斯特拉算法：基于已经求出的最短路径的基础上，求得更远顶点的最短路径，最后得到结果。
实现代码如下
#define MAXVEX 9
#define INFINITY 65535
typedef int Patharc[MAXVEX]
typedef int ShortPathTable[MAXVEX]
void ShortestPath_Dijkstar(MGraph G, int V0, Patharc *P, ShortPathTable *D)
{
int v,w,k,min;
int final[MAXVEX]; //已经求得顶点V0到Vw的最短路径
//初始化数据
for(v = 0; v< G.numVertexes ; v++)
{
final[v] = 0; //全部顶点初始化为未找到路径
(*D)[v]= G.arc[V0][v]; //将与 V0有连接线的顶点加上权值
(*P)[v] = 0; //初始化路径数组P为0
}
(*D)[V0] = 0; //V0到V0的路径为0
final[V0] = 1; //V0到V0不需要求路径
//开始主循环，每次求得V0到某个V顶点的最短路径
for( v=1;v< G.numVertexes ;v++)
{
min = INFINITY;
for( w = 0; w< G.numVertexes ;w++)
{
k = w;
min = (*D)[w];
}
final[k] = 1; //将目前找到的最近顶点置为1
//修正当前最短路径及距离
for(w = 0;w < G.numVertexes ;w++)
{
//如果经过v顶点的路径比现在这条短的话，更新
if(!final[w] && (min + G.arc[k][w] < (*D)[w]))
{
(*D)[w] = min + G.arc[k][w];
(*p)[w] = k;
}
}
}
}
最短路径之弗洛伊德算法
弗洛依德算法求所有顶点到所有顶点的最短路径，并且算法简洁。
代码实现
#define MAXVEX 9
#define INFINITY 65535
typedef int Pathmatirx[MAXVEX][MAXVEX]
typedef int ShortPathTable[MAXVEX][MAXVEX]
void ShortestPath_Floyd(MGraph G, int V0, Pathmatirx*P, ShortPathTable *D)
{
int v,w,k;
//初始化数据
for(v = 0; v< G.numVertexes ; v++)
{
(*D)[v][w]= G.arc[v][w];
(*P)[v][w] = w;
}
for( k=0;v< G.numVertexes ;k++)
{
for( v = 0; v< G.numVertexes ;v++)
{
for(w = 0;w < G.numVertexes ;w++)
{
if((*D)[v][w] > (*D)[v][k] + (*D)[k][w])
{
(*D)[v][w] = (*D)[v][k] + (*D)[k][w]
(*P)[v][w] = (*P)[v][k];
}
}
}
}
}