Dijkstra算法 算法基础篇（三）

// Dijkstra算法.cpp : 定义控制台应用程序的入口点。
//


#include <stdio.h>
#include <stdlib.h>
#define  NotAVertex (-1)
#define  NumVertex 20
#define  Infinity 1000
typedef int Vertex;
typedef int Arc;
typedef int DistType;

struct TableNode     //表节点
{
    Vertex V;
    DistType Weigh;       //边重
    struct TableNode* NextArc;
};

typedef struct TableNode* EdgeNode;

struct ListNode     //头节点
{
    Vertex V;
    EdgeNode FirstArc;
    DistType Dist;
    int  Known;
    Vertex Path;
};
typedef struct ListNode* VexNode; //定义头节点指针


struct Graphic                 //图的结构体 包括有边数，点数，头节点数组
{
    Vertex VertexNum;
    Arc    ArcNum;
    struct ListNode Adj[NumVertex];
};

typedef struct Graphic* Graph;

void ReadGraph(Graph G)             //图的输入函数
{
    Vertex from,to;
    DistType weight;
    struct TableNode *S;
    printf("请输入节点数和边数,注意为整型！\n");
    scanf("%d%d",&(G->VertexNum),&(G->ArcNum));
    if(G->ArcNum<=0||G->VertexNum<=0)
    {
        printf("图边数或点数必须大于零\n");
        return;
    }
    for(int i =0;i<G->ArcNum;i++)
    {
        printf("请输入第%d条边的起点，终点和权值！\n",i+1);
        scanf("%d%d%d",&from,&to,&weight);
        S=(EdgeNode)malloc(sizeof(struct TableNode));
        S->V=to;
        S->Weigh=weight;
        S->NextArc=G->Adj[from].FirstArc;       //这里是from的头边给S的下一条边，这里是表节点插入细节，好好体会下。
        G->Adj[from].FirstArc=S;
    }

}

void InitNode(Graph G)                     //图的初始化
{
    int i ;
    for(i=0;i<NumVertex;i++)
    {
        G->Adj[i].V=i;
        G->Adj[i].Path=NotAVertex;
        G->Adj[i].Known=false;
        G->Adj[i].Dist=Infinity;
        G->Adj[i].FirstArc=NULL;
    }
    ReadGraph(G);
    G->Adj[0].Dist=0;
}

Vertex ExtractMin(Graph G)                              //较为简单的寻找最小值函数，复杂度O（n），一直不是很满意
{
    int i;int j=Infinity;
    Vertex Min=Infinity;
    for(i=0;i<G->VertexNum;i++)
    {
        if(!(G->Adj[i].Known)&&Min>G->Adj[i].Dist)//刚开始犯了一个很傻的错误，这里的第二个条件放到第一个循环了，总是不对。
        {
            Min=G->Adj[i].Dist;
            j=i;
        }
    }
    if(j==Infinity) return -1;
    return j;
}

void PrintPath(Graph G,Vertex V)             //打印分支函数，只能打印一条分支。
{
    if(G->Adj[V].Path!=NotAVertex)
    {
        PrintPath(G,G->Adj[V].Path);
            printf("to");
    }
    printf("  %d  ",V);
}



void Dijkstra(Graph G)                      //函数：：步步贪心，最终全体贪心
{
    Vertex Value;
    EdgeNode pVex;
    for(int i=0;i<G->VertexNum;i++)
    {
        Value=ExtractMin(G);                     //抽取图中最小距离的点，纳入{S}
        if(Value==NotAVertex)
            break;
        G->Adj[Value].Known=true;
        pVex=G->Adj[Value].FirstArc;
    //    pEdge=pVex->NextArc;
        while(pVex!=NULL)                    //对图{Q-S}点的集合中与距离最小点毗邻的点做松弛操作
        {
            if(!(G->Adj[pVex->V].Known))     //邻接的节点更新
            {
                if(G->Adj[Value].Dist+pVex->Weigh< G->Adj[pVex->V].Dist)
                {
                    G->Adj[pVex->V].Dist=G->Adj[Value].Dist+pVex->Weigh;
                    G->Adj[pVex->V].Path=Value;
                }
            }
            pVex=pVex->NextArc;
        }
    }
}

Vertex ReturnDistMax(Graph G) //这个函数是为了方便Print调用的，可以不要。
{
    int i;
    Vertex key=0;
    DistType Max=0;
    for(i=0;i<G->VertexNum;i++)
        if(G->Adj[i].Dist>Max)
        {
            Max=G->Adj[i].Dist;
            key=i;
        }
        return key;


}


int _tmain(int argc, _TCHAR* argv[])
{
    int i;
    Vertex V;
    Graph G=(Graph)malloc(sizeof(Graphic));
    InitNode(G);
    Dijkstra(G);
    printf("\n");
    for(i=0;i<G->VertexNum;i++)
    {
        printf("##  %d  ##",G->Adj[i].Dist);
//        printf("##$  %d  $##",G->Adj[i].Path);
    }

    V=ReturnDistMax(G);
        
 //   PrintPath(G,V);



    return 0;
}