数据结构第十二周项目--验证算法

/*  
*Copyright(c)2017,烟台大学计算机与控制工程学院  
*All rights reserved.  
*作    者：李哲  
*版 本 号：v1.0  
*问题描述：验证算法 
*/  

（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;
}