数据结构——图的最短路径

要求：求给定图的中顶点A（第一个顶点，即邻接矩阵中第一行第一列）到其他顶点的最短路径。

采用的肯定是dijistra算法。该算法的思想就是从源节点开始，每一个下一步都是最优解以达成到目标节点的最优解。采用两个数组，用以记录节点是否被访问过以及最优路径的记录，即该数组中保存的是当前节点的上一步。每次新增一个节点就要更新dist[]数组，也就是记录距离的数组和pre[]数组，记录最优路径。

以下为代码。

#include <stdio.h>

#include <stdlib.h>

#define max 100

//要求：求给定图的中顶点A（第一个顶点，即邻接矩阵中第一行第一列）到其他顶点的最短路径。输入为-1表示无连接，也就是无穷大

//节点类

typedef struct node

{

    int label;

    struct node*next;

    int data;

}node;

//输入函数

void in(char a[],node *h[],int b[])

{

    int i=0;//外层循环变量

    int j=0;//j是a数组的计数变量

    int k=0;//b数组的循环变量

    for(i=0;i<5;i++)

    {

        gets(a);

        k=0;

        j=0;

        while(a[j]!='\0')

        {

            if (a[j]>='0'&&a[j]<='9')//输入为数字的情况

            {

                if (a[j+1]>='0'&&a[j]<='9')//输入为两位数

                {

                    b[k]=(int)(10*(a[j]-'0'))+(int)(a[j+1]-'0');

                    k++;

                    j+=2;

                    continue;

                }

                else//输入为一位数

                {

                    b[k]=(int)(a[j]-'0');

                    k++;

                    j++;

                    continue;

                }

            }

            else if (a[j]==' ')

            {

                j++;

                continue;

            }

            else if (a[j]=='-')

            {

                b[k]=-1;

                j+=2;

                k++;

                continue;

            }

        }

        //退出循环

        node*p;

        p=calloc(1,sizeof(node));

        p=h[i];

        for(k=0;k<5;k++)

        {

            if (b[k]==-1)

            {

                continue;

            }

            else if (b[k]==0)

            {

                continue;

            }

            else

            {

                node*q;

                q=calloc(1,sizeof(node));

                q->label=k;

                q->data=b[k];

                p->next=q;

                p=p->next;

                continue;

            }

        }

    }

}

//dist函数的初始赋值

void initd(int dist[],node*h[])

{

    dist[0]=0;

    node*p;

    p=calloc(1,sizeof(node));

    p=h[0];

    while (p->next!=NULL)

    {

        p=p->next;

        dist[p->label]=p->data;

    }

    int i=0;

    for ( i = 1; i < 5; i++)

    {

        if (dist[i]==0)

        {

            dist[i]=max;

            i++;

        }

    }

}

//求dist数组中最小值的位置，返回元素所在的位置

int min(int c[],int dist[])//c是记录数组

{

    int i=0;//循环变量

    int d=1;//暂存变量

    while (i<5)

    {

        if (dist[d]<=dist[i]&&c[d]==0)

        {

            i++;    

        }

        else if (dist[d]<=dist[i]&&c[d]==1)

        {

            d=i;

            i++;

        }

        else if (dist[d]>=dist[i]&&c[d]==1)

        {

            d=i;

            i++;

        }

        else if (dist[d]>dist[i]&&c[d]==0&&c[i]==0)

        {

            d=i;

            i++;

        }

        else if (dist[d]>dist[i]&&c[d]==0)

        {

            i++;

        }

    }

    return d;

}

//求节点的权重函数,从h1到h2,h1和h2是相邻关系

int weight(int dist[],node*h1,node*h2)

{

    node*p;

    p=calloc(1,sizeof(node));

    p=h1;

}

//查找两点之间的最短路径

void mindist(int c[],int pre[],int dist[],node*h[])

{

    int d=0;//接收min的返回值

    d=min(c,dist);

    c[d]=1;//开始修改dist数值

    node*p;

    p=calloc(1,sizeof(node));

    p=h[d];

    int distance=0;

    distance+=dist[d];

    while(p->next!=NULL)

    {

        if (dist[p->next->label]>distance+p->next->data)

        {

            dist[p->next->label]=distance+p->next->data;

            pre[p->next->label]=d;

        }

        if (c[p->next->label]==0)

        {

            break;

        }

        p=p->next;

    }

}

int main()

{

    char a[20]={'\0'};

    int b[5]={0};

    node*h[5];

    int i=0;

    for ( i = 0; i < 5; i++)

    {

        h[i]=calloc(1,sizeof(node));

        h[i]->label=i;

    }

    in(a,h,b);

    int dist[5]={0};//最短路径记录数组

    int pre[5]={0};//最短路径的轨迹记录数组

    //需要一个dist函数的初始赋值

    initd(dist,h);

    int c[5]={0};//记录数组，用于记录S，也就是已经位于最短路径集合内的节点

    c[0]=1;

    pre[0]=-1;

    node*p;

    p=calloc(1,sizeof(node));

    p=h[0];

    while(p->next!=NULL)

    {

        p=p->next;

        pre[p->label]=0;

    }

    c[0]=1;

    //以上完成了pre数组的初始化

    for ( i = 0; i < 4; i++)

    {

        mindist(c,pre,dist,h);

    }

    for ( i = 0; i < 5; i++)

    {

        printf("%d ",dist[i]);

    }

    return 0;

}