第十二周项目1 - 验证算法（1）（2）（3）（4）（5）

/*  

*Copyright  (c)2017,烟台大学计算机与控制工程学院      

*All rights reservrd.      

*文件名称 ：test.cpp      

*作者：潘亚楠  

*完成时间：2017年12月15日      

*版本号：v1.0      

*问题描述: 验证算法

问题及代码：

程序中graph.h是图存储结构的“算法库”中的头文件，详情请单击链接…

（1）Prim算法的验证

#include <stdio.h>  
#include <malloc.h>  
#include "graph.h"  
  
void Prim(MGraph g,int v)  
{  
    int lowcost[MAXV];          //顶点i是否在U中  
    int min;  
    int closest[MAXV],i,j,k;  
    for (i=0; i<g.n; i++)           //给lowcost[]和closest[]置初值  
    {  
        lowcost[i]=g.edges[v][i];  
        closest[i]=v;  
    }  
    for (i=1; i<g.n; i++)           //找出n-1个顶点  
    {  
        min=INF;  
        for (j=0; j<g.n; j++)     //在(V-U)中找出离U最近的顶点k  
            if (lowcost[j]!=0 && lowcost[j]<min)  
            {  
                min=lowcost[j];  
                k=j;            //k记录最近顶点的编号  
            }  
        printf(" 边(%d,%d)权为:%d\n",closest[k],k,min);  
        lowcost[k]=0;           //标记k已经加入U  
        for (j=0; j<g.n; j++)       //修改数组lowcost和closest  
            if (g.edges[k][j]!=0 && g.edges[k][j]<lowcost[j])  
            {  
                lowcost[j]=g.edges[k][j];  
                closest[j]=k;  
            }  
    }  
}  
  
int main()  
{  
    MGraph g;  
    int A[6][6]=  
    {  
        {0,6,1,5,INF,INF},  
        {6,0,5,INF,3,INF},  
        {1,5,0,5,6,4},  
        {5,INF,5,0,INF,2},  
        {INF,3,6,INF,0,6},  
        {INF,INF,4,2,6,0}  
    };  
    ArrayToMat(A[0], 6, g);  
    printf("最小生成树构成:\n");  
    Prim(g,0);  
    return 0;  
}  

（2）Kruskal算法的验证

#include <stdio.h>  
#include <malloc.h>  
#include "graph.h"  
#define MaxSize 100  
typedef struct  
{  
    int u;     //边的起始顶点  
    int v;     //边的终止顶点  
    int w;     //边的权值  
} Edge;  
  
void InsertSort(Edge E[],int n) //对E[0..n-1]按递增有序进行直接插入排序  
{  
    int i,j;  
    Edge temp;  
    for (i=1; i<n; i++)  
    {  
        temp=E[i];  
        j=i-1;              //从右向左在有序区E[0..i-1]中找E[i]的插入位置  
        while (j>=0 && temp.w<E[j].w)  
        {  
            E[j+1]=E[j];    //将关键字大于E[i].w的记录后移  
            j--;  
        }  
        E[j+1]=temp;        //在j+1处插入E[i]  
    }  
}  
  
void Kruskal(MGraph g)  
{  
    int i,j,u1,v1,sn1,sn2,k;  
    int vset[MAXV];  
    Edge E[MaxSize];    //存放所有边  
    k=0;                //E数组的下标从0开始计  
    for (i=0; i<g.n; i++)   //由g产生的边集E  
        for (j=0; j<g.n; j++)  
            if (g.edges[i][j]!=0 && g.edges[i][j]!=INF)  
            {  
                E[k].u=i;  
                E[k].v=j;  
                E[k].w=g.edges[i][j];  
                k++;  
            }  
    InsertSort(E,g.e);      //采用直接插入排序对E数组按权值递增排序  
    for (i=0; i<g.n; i++)   //初始化辅助数组  
        vset[i]=i;  
    k=1;    //k表示当前构造生成树的第几条边,初值为1  
    j=0;    //E中边的下标,初值为0  
    while (k<g.n)       //生成的边数小于n时循环  
    {  
        u1=E[j].u;  
        v1=E[j].v;      //取一条边的头尾顶点  
        sn1=vset[u1];  
        sn2=vset[v1];   //分别得到两个顶点所属的集合编号  
        if (sn1!=sn2)   //两顶点属于不同的集合  
        {  
            printf("  (%d,%d):%d\n",u1,v1,E[j].w);  
            k++;                     //生成边数增1  
            for (i=0; i<g.n; i++)   //两个集合统一编号  
                if (vset[i]==sn2)   //集合编号为sn2的改为sn1  
                    vset[i]=sn1;  
        }  
        j++;               //扫描下一条边  
    }  
}  
  
int main()  
{  
    MGraph g;  
    int A[6][6]=  
    {  
        {0,6,1,5,INF,INF},  
        {6,0,5,INF,3,INF},  
        {1,5,0,5,6,4},  
        {5,INF,5,0,INF,2},  
        {INF,3,6,INF,0,6},  
        {INF,INF,4,2,6,0}  
    };  
    ArrayToMat(A[0], 6, g);  
    printf("最小生成树构成:\n");  
    Kruskal(g);  
    return 0;  
}  

（3）Dijkstra算法的验证

#include <stdio.h>  
#include <malloc.h>  
#include "graph.h"  
#define MaxSize 100  
void Ppath(int path[],int i,int v)  //前向递归查找路径上的顶点  
{  
    int k;  
    k=path[i];  
    if (k==v)  return;          //找到了起点则返回  
    Ppath(path,k,v);            //找顶点k的前一个顶点  
    printf("%d,",k);            //输出顶点k  
}  
void Dispath(int dist[],int path[],int s[],int n,int v)  
{  
    int i;  
    for (i=0; i<n; i++)  
        if (s[i]==1)  
        {  
            printf("  从%d到%d的最短路径长度为:%d\t路径为:",v,i,dist[i]);  
            printf("%d,",v);    //输出路径上的起点  
            Ppath(path,i,v);    //输出路径上的中间点  
            printf("%d\n",i);   //输出路径上的终点  
        }  
        else  printf("从%d到%d不存在路径\n",v,i);  
}  
void Dijkstra(MGraph g,int v)  
{  
    int dist[MAXV],path[MAXV];  
    int s[MAXV];  
    int mindis,i,j,u;  
    for (i=0; i<g.n; i++)  
    {  
        dist[i]=g.edges[v][i];      //距离初始化  
        s[i]=0;                     //s[]置空  
        if (g.edges[v][i]<INF)      //路径初始化  
            path[i]=v;  
        else  
            path[i]=-1;  
    }  
    s[v]=1;  
    path[v]=0;              //源点编号v放入s中  
    for (i=0; i<g.n; i++)               //循环直到所有顶点的最短路径都求出  
    {  
        mindis=INF;                 //mindis置最小长度初值  
        for (j=0; j<g.n; j++)       //选取不在s中且具有最小距离的顶点u  
            if (s[j]==0 && dist[j]<mindis)  
            {  
                u=j;  
                mindis=dist[j];  
            }  
        s[u]=1;                     //顶点u加入s中  
        for (j=0; j<g.n; j++)       //修改不在s中的顶点的距离  
            if (s[j]==0)  
                if (g.edges[u][j]<INF && dist[u]+g.edges[u][j]<dist[j])  
                {  
                    dist[j]=dist[u]+g.edges[u][j];  
                    path[j]=u;  
                }  
    }  
    Dispath(dist,path,s,g.n,v);     //输出最短路径  
}  
  
int main()  
{  
    MGraph g;  
    int A[7][7]=  
    {  
        {0,4,6,6,INF,INF,INF},  
        {INF,0,1,INF,7,INF,INF},  
        {INF,INF,0,INF,6,4,INF},  
        {INF,INF,2,0,INF,5,INF},  
        {INF,INF,INF,INF,0,INF,6},  
        {INF,INF,INF,INF,1,0,8},  
        {INF,INF,INF,INF,INF,INF,0}  
    };  
    ArrayToMat(A[0], 7, g);  
    Dijkstra(g,0);  
    return 0;  
}  

（4）Floyd算法验证

#include <stdio.h>  
#include <malloc.h>  
#include "graph.h"  
#define MaxSize 100  
void Ppath(int path[][MAXV],int i,int j)  //前向递归查找路径上的顶点  
{  
    int k;  
    k=path[i][j];  
    if (k==-1) return;  //找到了起点则返回  
    Ppath(path,i,k);    //找顶点i的前一个顶点k  
    printf("%d,",k);  
    Ppath(path,k,j);    //找顶点k的前一个顶点j  
}  
void Dispath(int A[][MAXV],int path[][MAXV],int n)  
{  
    int i,j;  
    for (i=0; i<n; i++)  
        for (j=0; j<n; j++)  
        {  
            if (A[i][j]==INF)  
            {  
                if (i!=j)  
                    printf("从%d到%d没有路径\n",i,j);  
            }  
            else  
            {  
                printf("  从%d到%d=>路径长度:%d 路径:",i,j,A[i][j]);  
                printf("%d,",i);    //输出路径上的起点  
                Ppath(path,i,j);    //输出路径上的中间点  
                printf("%d\n",j);   //输出路径上的终点  
            }  
        }  
}  
void Floyd(MGraph g)  
{  
    int A[MAXV][MAXV],path[MAXV][MAXV];  
    int i,j,k;  
    for (i=0; i<g.n; i++)  
        for (j=0; j<g.n; j++)  
        {  
            A[i][j]=g.edges[i][j];  
            path[i][j]=-1;  
        }  
    for (k=0; k<g.n; k++)  
    {  
        for (i=0; i<g.n; i++)  
            for (j=0; j<g.n; j++)  
                if (A[i][j]>A[i][k]+A[k][j])  
                {  
                    A[i][j]=A[i][k]+A[k][j];  
                    path[i][j]=k;  
                }  
    }  
    Dispath(A,path,g.n);   //输出最短路径  
}  
int main()  
{  
    MGraph g;  
    int A[4][4]=  
    {  
        {0,  5,INF,7},  
        {INF,0,  4,2},  
        {3,  3,  0,2},  
        {INF,INF,1,0}  
    };  
    ArrayToMat(A[0], 4, g);  
    Floyd(g);  
    return 0;  
}  

（5）拓扑排序算法验证

#include <stdio.h>  
#include <malloc.h>  
#include "graph.h"  
  
void TopSort(ALGraph *G)  
{  
    int i,j;  
    int St[MAXV],top=-1;            //栈St的指针为top  
    ArcNode *p;  
    for (i=0; i<G->n; i++)          //入度置初值0  
        G->adjlist[i].count=0;  
    for (i=0; i<G->n; i++)          //求所有顶点的入度  
    {  
        p=G->adjlist[i].firstarc;  
        while (p!=NULL)  
        {  
            G->adjlist[p->adjvex].count++;  
            p=p->nextarc;  
        }  
    }  
    for (i=0; i<G->n; i++)  
        if (G->adjlist[i].count==0)  //入度为0的顶点进栈  
        {  
            top++;  
            St[top]=i;  
        }  
    while (top>-1)                  //栈不为空时循环  
    {  
        i=St[top];  
        top--;              //出栈  
        printf("%d ",i);            //输出顶点  
        p=G->adjlist[i].firstarc;   //找第一个相邻顶点  
        while (p!=NULL)  
        {  
            j=p->adjvex;  
            G->adjlist[j].count--;  
            if (G->adjlist[j].count==0)//入度为0的相邻顶点进栈  
            {  
                top++;  
                St[top]=j;  
            }  
            p=p->nextarc;       //找下一个相邻顶点  
        }  
    }  
}  
  
int main()  
{  
    ALGraph *G;  
    int A[7][7]=  
    {  
        {0,0,1,0,0,0,0},  
        {0,0,0,1,1,0,1},  
        {0,0,0,1,0,0,0},  
        {0,0,0,0,1,1,0},  
        {0,0,0,0,0,0,0},  
        {0,0,0,0,0,0,0},  
        {0,0,0,0,0,1,0}  
    };  
    ArrayToList(A[0], 7, G);  
    DispAdj(G);  
    printf("\n");  
    printf("拓扑序列:");  
    TopSort(G);  
    printf("\n");  
    return 0;  
}  

运行结果：