数据结构---图论

prim算法：

prim算法是一种从一个点开始，找到其连接的点中距离最小的边，然后将那个点拉入集合，然后在从这个集合找连接下一个点的边，一定是最小的，当连接所有点，既把所有点拉入集合当中，算法结束。

下面一道题：找某点到某点的最小value权值

#include <bits/stdc++.h>
using namespace std;

#define INF 0X3f3f3f3f

typedef struct {
    int va;
    int flag;
    int pre;
} vertex;

int Gra[105][105];
vertex V[105];

// 初始化,使其不连接
void init(int l) {
    int i, j;

    for(i=1;i<=l;i++) {
        for(j=1;j<=l;j++) {
            Gra[i][j]=INF;
        }
    }
}

void prim(int be, int l) {
    int i,j;
    int min_va, min_v;
//根据start初始化点，cost为权值，flag表示是否已经搜寻过该点
    for(i=1;i<=l;i++) {
        V[i].va=Gra[be][i];
        V[i].flag=0;
        V[i].pre=be;
    }
//将第一个点加入
    V[be].va=0;
    V[be].flag=1;

    for(i=2;i<=l;i++) {
        min_va=INF; //找权值最少的边
        for(j=1;j<=l;j++) {
            if(V[j].flag==0&&V[j].va<min_va) {
                min_va=V[j].va;
                min_v=j;
            }
        }
        V[min_v].flag = 1;  //将找到的边加入到集合
        for(j=1;j<=l;j++) {        // 根据新加入的点调整各点权值
            if(V[j].flag==0&&V[j].va>Gra[min_v][j]) {
            V[j].va=Gra[min_v][j];
                V[j].pre=min_v;
            }
        }
    }
}

int main() {
    int i;
    int ver_num, edge_num;
    int edge_u, edge_v, cost;
    scanf("%d %d", &ver_num, &edge_num);
    init(ver_num);

    for(i = 1; i <= edge_num; i++) {
        scanf("%d %d %d", &edge_u, &edge_v, &cost);
        Gra[edge_u][edge_v]=cost;
        Gra[edge_v][edge_u]=cost;
    }
    prim(1,ver_num);
    for(i = 2; i <= ver_num; i++) {
        printf("%d 到 %d,权值为 %d\n", V[i].pre, i, V[i].va);   
    }

    return 0;
}

Kruskal算法：

与Prim算法不同，思路就是把边从小到大排序，然后看边是否会变成环，否则加入到集合，知道遍历完所有边或者生成了最小生成树。

算法就不写了，下面介绍迪杰斯特拉算法，也就是Dijkstra算法

是寻找最短路径的方法，原理就是从出发点开始找到最小边，然后逐渐更新，最终找到其到其他边的最小距离，注意不能出现负值，既负权值。贴一下我曾经写过的博客：

链接 https://blog.csdn.net/qq_43632924/article/details/86610037

实现代码：

int i,j,k,min,tmp;

void dij（int start，int dist【】，flag【】） //dist【i】意是点start到点i的距离，flag【i】=0意思是点start到i的距离最小值未得到，=1意思是已经得到最短距离。我们确立flag的目的是防止重复与过多的循环。

{

for(i=1;i<=n;++i)     //详细的没有指出，n是指全部的点

{flag[i]=0;

dist[i]=long[1][i]     //long表示1-i之间的距离   }

flag【start】=1；  //出发点与出发点的最短距离，默认为已知

dist【start】=0；  //出发点与出发点的距离0；

//这之后就是在从start1步到达end和n-1步到达end的最短距离的比较选择，也是dij中的核心

for（i=1；i<n；++i）{

min=inf;   //inf是一个极大值，表示无穷大的数。

for(j=1;j<=n;++j) if(flag[j]==0&&dist[j]<min)  {min=dist[j]; k=j;}

flag[k]=1;  //因为一步里面到达的它是距离最少的，所以start到k点距离最小。

//下面的循环就是求第二步到第n-1步最小值的。不太好掌握

for（j=1；j<=n;++j）{ tmp= long[k][j]==INF ? INF : (min + mMatrix[k][j]));  if(flag[j]==0&&dist[j]>temp) dist【j】=tmp；}//不仅如此，在这一步中我们得到了每一个分两步到达各点的距离的最小值，然后返回上一个循环找到两步到达的最小值的点，然后再进行这一个循环得到分三步到达的点的距离的最小值，以此类推。

然后我们想要到哪个点，直接用dist【i】就是最小距离点了。

}

迪杰斯特拉算法是有出发点的，不同于迪杰斯特拉算法，Floyd弗洛伊德算法是没有出发点的，他可以找任何两点的距离，所以我们可以写个循环，调用n次迪杰斯特拉算法即可，每次出发点不一样，用个二维数组存距离，这样的算法就是Floyd算法，整体思想与dijstra算法相同，就不写模板了。

拓扑排序：
 

拓扑排序就是找图里面有没有环。

思路：

在AOV网中若顶点vi到vj之间存在一条有向的路径，那么说vi是vj的前驱，vj是vi的后继，若<vi,vj>是AOV网中的弧，则称vi是vj的直接前驱，vj是vi的直接后继

一般用栈来实现

for (i=0;i<ad.L;i++)    //将入度为0的点放入栈中，既没有前驱的点
{
    if (ad[i].In==0)
    {
        stack.Push(i);
    }  
}

 

while (stack.Count!=0)  //取栈顶元素，count累加，e为取出链接表的节点，遍历e直到末尾，将链表节点存入k如果k入度减一为

                                     //0，则存入栈中
{
    gettop = stack.Pop();
    count++;
    for (e = ad[gettop].First; e!=null; e = e.Next)
    {
        k=e.AdjVex;
        if (--ad[k].In== 0){
            stack.Push(k);
        }
    }
}
最后看count是不是节点数，是那么无环，不是则有环