图算法：普里姆算法、迪杰斯特拉算法、弗洛伊德算法

prim1.h

#ifndef PRIM_H
#define PRIM_H

//* 普里姆算法,求最小生成树 
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

#define MAX_VERTEX_NUM 5
#define INFINITY 1000//这里不能用INT_MAX，因为如果是整型正数的最大值，加一后反而变成最小值，这点要注意

typedef int VRType;
typedef int VertexType;
typedef char InfoType;
typedef enum{DG,DN,UDG,UDN}GraphKind;//图种类，分别表示有向图，有向网，无向图，无向网
typedef enum{ERROR,OK}Status;
typedef bool PathMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef bool PathMatrix2[MAX_VERTEX_NUM][MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef int ShortPathTable[MAX_VERTEX_NUM];
typedef int ShortPathTable2[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

typedef struct ArcCell//边信息
{
    VRType adj;//边的权值
    InfoType *info;//边的其它信息,本示例中假设info均为空
}ArcCell,ArcMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

typedef struct  
{
    VertexType vexs[MAX_VERTEX_NUM];
    ArcMatrix arc;
    int vexNum,arcNum;
    GraphKind kind;
}MGraph;//使用数组形式表示图

typedef struct  
{
    VertexType adjvex;
    VRType lowcost;
}closing[MAX_VERTEX_NUM];

int Locate(MGraph g,VertexType v)
{
    for(int i = 0;i < g.vexNum;i++)
    {
        if(g.vexs[i] == v)
        {
            return i;
        }
    }
    return -1;
}

Status CreateDG(MGraph &g)//构造有向图
{
    VertexType v1,v2;
    VRType arcValue;

    printf("cerate the DG:\n");
    printf("please input the vexNum and arcNum:\n");
    scanf("%d %d",&g.vexNum,&g.arcNum);

    printf("\nplease input the value of the vertex:\n");
    for(int i = 0;i < g.vexNum;i++)
    {
        scanf("%d",&g.vexs[i]);
    }

    for(int i = 0;i < g.vexNum;i++)
    {
        for(int j = 0;j < g.vexNum;j++)
        {
            g.arc[i][j].adj = INFINITY;
            g.arc[i][j].info = NULL;
        }
    }

    printf("\nplease input the arc of the graph:\n");
    for(int i = 0;i < g.arcNum;i++)
    {
        scanf("%d %d %d",&v1,&v2,&arcValue);
        int l1 = Locate(g,v1);
        int l2 = Locate(g,v2);
        g.arc[l1][l2].adj = arcValue;
    }

    return OK;
}

Status CreateDN(MGraph &g)//构造有向网
{
    VertexType v1,v2;
    VRType arcValue;

    printf("cerate the DN:\n");
    printf("please input the vexNum and arcNum:\n");
    scanf("%d %d",&g.vexNum,&g.arcNum);

    printf("\nplease input the value of the vertex:\n");
    for(int i = 0;i < g.vexNum;i++)
    {
        scanf("%d",&g.vexs[i]);
    }

    for(int i = 0;i < g.vexNum;i++)
    {
        for(int j = 0;j < g.vexNum;j++)
        {
            g.arc[i][j].adj = INFINITY;
            g.arc[i][j].info = NULL;
        }
    }

    printf("\nplease input the arc of the graph:\n");
    for(int i = 0;i < g.arcNum;i++)
    {
        scanf("%d %d %d",&v1,&v2,&arcValue);
        int l1 = Locate(g,v1);
        int l2 = Locate(g,v2);
        g.arc[l1][l2].adj = arcValue;
    }

    return OK;
}

Status CreateUDG(MGraph &g)//构造无向图
{
    VertexType v1,v2;
    VRType arcValue;

    printf("cerate the UDG:\n");
    printf("please input the vexNum and arcNum:\n");
    scanf("%d %d",&g.vexNum,&g.arcNum);

    printf("\nplease input the value of the vertex:\n");
    for(int i = 0;i < g.vexNum;i++)
    {
        scanf("%d",&g.vexs[i]);
    }

    for(int i = 0;i < g.vexNum;i++)
    {
        for(int j = 0;j < g.vexNum;j++)
        {
            g.arc[i][j].adj = INFINITY;
            g.arc[i][j].info = NULL;
        }
    }

    printf("\nplease input the arc of the graph:\n");
    for(int i = 0;i < g.arcNum;i++)
    {
        scanf("%d %d %d",&v1,&v2,&arcValue);
        int l1 = Locate(g,v1);
        int l2 = Locate(g,v2);
        g.arc[l1][l2].adj = arcValue;
        g.arc[l2][l1].adj = arcValue;
    }

    return OK;
}

Status CreateUDN(MGraph &g)//构造无向网
{
    VertexType v1,v2;
    VRType arcValue;

    printf("cerate the UDN:\n");
    printf("please input the vexNum and arcNum:\n");
    scanf("%d %d",&g.vexNum,&g.arcNum);

    printf("\nplease input the value of the vertex:\n");
    for(int i = 0;i < g.vexNum;i++)
    {
        scanf("%d",&g.vexs[i]);
    }

    for(int i = 0;i < g.vexNum;i++)
    {
        for(int j = 0;j < g.vexNum;j++)
        {
            g.arc[i][j].adj = INFINITY;
            g.arc[i][j].info = NULL;
        }
    }

    printf("\nplease input the arc of the graph:\n");
    for(int i = 0;i < g.arcNum;i++)
    {
        scanf("%d %d %d",&v1,&v2,&arcValue);
        int l1 = Locate(g,v1);
        int l2 = Locate(g,v2);
        g.arc[l1][l2].adj = arcValue;
        g.arc[l2][l1].adj = arcValue;
    }

    return OK;
}

Status CreateMGraph(MGraph &g)
{
    printf("please input the kind of the graph :\n");
    scanf("%d",&g.kind);
    switch(g.kind)
    {
    case DG:
        return CreateDG(g);
    case DN:
        return CreateDN(g);
    case UDG:
        return CreateUDG(g);
    case UDN:
        return CreateUDN(g);
    default:
        return OK;
    }
}

void PrintMGraph(MGraph g)
{
    printf("the vertex of the graph is :\n");
    for(int i = 0;i < g.vexNum;i++)
    {
        printf("%d ",g.vexs[i]);
    }
    printf("\n");

    printf("the arc of the graph is :\n");
    for(int i = 0;i < g.vexNum;i++)
    {
        for(int j = 0;j < g.vexNum;j++)
        {
            printf("%d ",g.arc[i][j].adj);
        }
        printf("\n");
    }
    printf("\n");
}

int MinCostLocate(int num,closing clos)//这里传递图的节点数比传递图本身效率要高，所以主要参数的类型选择
{
    int i;
    for(i = 0;i < num;i++)//寻找第一个lowcost不为0的下标
    {
        if(clos[i].lowcost != 0)
        {
            break;
        }
    }
    if(i == num)
    {
        return -1;
    }
    VRType vr = clos[i].lowcost;
    int min = i;
    for(i = i+1;i < num;i++)
    {
        if(vr > clos[i].lowcost && clos[i].lowcost > 0)
        {
            vr = clos[i].lowcost;
            min = i;
        }
    }
    return min;
}

void MiniSpanTreePrim(MGraph g)//普里姆算法
{
    VertexType v;
    printf("please input the start vertex:\n");
    scanf("%d",&v);//输入起始点值

    closing clos;
    int k = Locate(g,v);//将起始点值转换为数组坐标

    for(int i = 0;i < g.vexNum;i++)
    {
        if(i != k)
        {
            clos[i].adjvex = v;
            clos[i].lowcost = g.arc[k][i].adj;
        }
    }
    clos[k].lowcost = 0;

    for(int j = 1;j < g.vexNum;j++)//总的次数,n个点有n-1条边，所以只需要循环n-1次
    {
        k = MinCostLocate(g.vexNum,clos);
        if(k != -1)
        {

            printf("%d %d\n",clos[k].adjvex,g.vexs[k]);
            clos[k].lowcost = 0;
            for(int i = 0;i < g.vexNum;i++)
            {
                if(g.arc[k][i].adj < clos[i].lowcost)
                {
                    clos[i].lowcost = g.arc[k][i].adj;
                    clos[i].adjvex = g.vexs[k];
                }
            }
        }
    }
}

void ShortestPathDIJ(MGraph g,VertexType vp,PathMatrix &p,ShortPathTable &d)//迪杰斯特拉算法求给定点到其他点的最短路径
{
    int v0 = Locate(g,vp);
    int v;
    bool *fault = (bool *)malloc(sizeof(bool)*g.vexNum);

    for(v = 0;v < g.vexNum;v++)
    {
        d[v] = g.arc[v0][v].adj;
        fault[v] = false;
        for(int w = 0;w < g.vexNum;w++)
        {
            p[v][w] = false;
        }
        if(d[v] < INFINITY)
        {
            p[v][v0] = true;
            p[v][v] = true;
        }
    }

    d[v0] = 0;
    fault[v0] = true;

    for(int count = 1;count < g.vexNum;count++)
    {
        int min = INFINITY;//min用于每次循环后更新到各点最短距离
        for(int w = 0;w < g.vexNum;w++)
        {
            if(!fault[w])
            {
                if(d[w] < min)
                {
                    min = d[w];
                    v = w;
                }
            }
        }
    
        fault[v] = true;

        for(int w = 0;w < g.vexNum;w++)
        {
            if(!fault[w])
            {
                if((min+g.arc[v][w].adj) < d[w])
                {
                    d[w] = min+g.arc[v][w].adj;
                    for(int i = 0;i < g.vexNum;i++)
                    {
                        p[w][i] = p[v][i];
                    }
                    p[w][w] = true;
                }
            }
        }
    }
}

void ShortestPathFLOYD(MGraph g,PathMatrix2 &p,ShortPathTable2 &d)//弗洛伊德算法求任意2点间的最短路径
{
    for(int i = 0;i < g.vexNum;i++)
    {
        for(int j = 0;j < g.vexNum;j++)
        {
            d[i][j] = g.arc[i][j].adj;
            d[i][i] = 0;//自己到自己的距离是0
            for(int v = 0;v < g.vexNum;v++)
            {
                p[i][j][v] = false;
            }
            if(d[i][j] < INFINITY)
            {
                p[i][j][i] = true;
                p[i][j][j] = true;
            }
        }
    }

    for(int i = 0;i < g.vexNum;i++)
    {
        for(int j = 0;j < g.vexNum;j++)
        {
            for(int k = 0;k < g.vexNum;k++)
            {
                if(d[j][k] > (d[j][i]+d[i][k]))
                {
                    d[j][k] = d[j][i]+d[i][k];
                    for(int v = 0;v < g.vexNum;v++)
                    {
                        p[j][k][v] = p[j][i][v]||p[i][k][v];
                    }
                }
            }
        }
    }
}

#endif

main.cpp

#include "prim1.h"

int main()
{
    MGraph g;
    CreateMGraph(g);//构造图
    PrintMGraph(g);//打印图
    MiniSpanTreePrim(g);//用普里姆算法求最小生成树

    printf("please input the start point of the tree:\n");

    VertexType vp;
    scanf("%d",&vp);
    PathMatrix p;
    ShortPathTable d;
    ShortestPathDIJ(g,vp,p,d);//用迪杰斯特拉算法求最短路径问题

    printf("DJI :\nthe shortest path form %d to other points is :\n",vp);
    for(int i = 0;i < g.vexNum;i++)
    {
        if(vp != g.vexs[i])
        {
            printf("%d to %d : ",vp,g.vexs[i]);
            for(int t = 0;t < g.vexNum;t++)
            {
                if(p[i][t])
                {
                    printf("%d ",g.vexs[t]);
                }
            }
            printf("\nthe total length of the path is : %d\n\n",d[i]);
        }
    }

    PathMatrix2 p2;
    ShortPathTable2 d2;
    ShortestPathFLOYD(g,p2,d2);

    printf("FLOYD:\n");
    for(int w = 0;w < g.vexNum;w++)
    {
        printf("the shortest path form %d to other points is :\n",g.vexs[w]);

        for(int i = 0;i < g.vexNum;i++)
        {
            printf("%d to %d :\n",g.vexs[w],g.vexs[i]);
            for(int j = 0;j < g.vexNum;j++)
            {
                if(p2[w][i][j])
                {
                    printf("%d ",g.vexs[j]);
                }
            }
            printf("the total length of this path is : %d \n\n",d2[w][i]);
        }
    }

    system("pause");
    return 0;
}