数据结构——Dijkstra算法——顺序存储

#include<stdio.h>
#include"structure.c"

typedef struct dist
{
          VerTaxType vexs;
          int  dist;
}dist;

typedef struct path
{
          VerTaxType vexs;
          VerTaxType path;
}path;

//初始化dist 和 path
void initialDijkstra(AMGraph *G,VerTaxType S, dist dist[],path path[],int Collected[]){ //S代表source,起点

          //初始path ，dist
          for (int i = 0; i <G->vexsNum ; i++)
          {         
                    //初始化dist和path的关键字
                    dist[i].vexs=G->vexs[i];
                    path[i].vexs=G->vexs[i];
                    //将起始点的出度 矩阵行的值赋予dist。这样就知道起始点连接了哪些节点
                    dist[i].dist=G->arcs[LocateVexNum(*G,S)][i];
                    // 如果dist列表中的值小于无穷，说明有出度节点
                    if(dist[i].dist<MaxInt){
                              path[i].path=S;
                    }else
                    {
                              path[i].path='X';
                              Collected[i]=0;
                    }
                    
          }

          //先将起始节点的dist值和path值以及 收录到Collected数组中
          Collected[LocateVexNum(*G,S)]=1;
          dist[LocateVexNum(*G,S)].dist=0;
         
          
}

//找dist值中的最小者，进行贪心吞并
VerTaxType FindMinDist(AMGraph *G, dist dist[],int Collected[]){
          
          //定义一个最小点：需要最后进行返回
          VerTaxType min;
          // 定义一个最小距离：作比较用
          int minDis=MaxInt;
          for (int  i = 0; i < G->vexsNum; i++)
          {
                    if(dist[i].dist<minDis&&Collected[i]!=1){
                              minDis=dist[i].dist;
                              min=G->vexs[i];//最小节点
                    }
          }

          //如果最小距离小于MaxInt，说明节点存在
          if (minDis<MaxInt)
          {
                    return min;
          }else
          {
                    return 0;
          }
          
          
          
}

//主要的迪杰斯特拉算法
void Dijktra(AMGraph *G,VerTaxType S,dist dist[],path path[]){
          //创建一个收纳最小生成树成员数组
          int Collected[MaxVerTax];

          // 初始化
          initialDijkstra(G,S,dist,path,Collected);

          while (1)
          {        
                    //找一个距离最小值的节点,来作为根节点的侦查兵V
                 VerTaxType V= FindMinDist(G,dist,Collected);
          //        如果没有V，就说明全部节点都已经收入Collected数组中了
                 if (V==0)
                 {
                         break;
                 }
          //        将侦查兵囊如阵营中
                    Collected[LocateVexNum(*G,V)]=1;
                    //遍历每一个点
                    for (int W = 0; W <G->vexsNum; W++)
                    {         
                              //如果点未被收录，那么就来找找最短距离
                            //   if(Collected[W]!=1&&G->arcs[LocateVexNum(*G,V)][W]<MaxInt){
                            if(Collected[W]!=1){        

                                        // 如果侦察兵离目标的距离加 侦察兵到根节点的距离小于 无穷，说明侦查兵能探查到，那么就更新距离
                                        int V_W_Dis=G->arcs[LocateVexNum(*G,V)][W];//侦察兵到目标的距离
                                        if ((dist[LocateVexNum(*G,V)].dist+V_W_Dis)<dist[W].dist)//**********
                                        {
                                                  //更新源节点到目标节点的距离
                                                  int aa=dist[LocateVexNum(*G,V)].dist;
                                                  int bb=V_W_Dis;

                                                  dist[W].dist=dist[LocateVexNum(*G,V)].dist+V_W_Dis;
                                                  path[W].path=V;
                                        }
                                        
                              }
                    }
                    
                 
          }
          
}



int main(int argc, char const *argv[])
{
          AMGraph xxx;
          initialMatrix(&xxx);
          CreateAMGraph(&xxx,7,12);
          printf("图的邻接矩阵:\n");
          printMaxtrix(&xxx);

          printf("下面是Dijkstra：\n");

          VerTaxType S='a';
          dist dist[MaxVerTax];
          path path[MaxVerTax];
          Dijktra(&xxx,S,dist,path);
          
          printf("节点：");

          for (int i = 0; i < xxx.vexsNum; i++)
          {
                    printf("%c ",xxx.vexs[i]);
          }
          
            printf("\n");
          //输出数组
          printf("距离：");

          for (int i = 0; i < xxx.vexsNum; i++)
          {
                    printf("%d ",dist[i].dist);

          }
          
          printf("\n");
          printf("路径：");
          
          for (int i = 0; i <xxx.vexsNum; i++)
          {
                    printf("%c ",path[i].path);
          }
          
          printf("\n");
          return 0;
}