邻接表Dijkstra

#include <stdio.h>
#include <malloc.h>

#define true 1
#define false 0
#define INFINITY 1000000
#define MaxVertexNum 100
#define MaxArcNum 100

struct VisiteStruct {
    int Dist;
    int Known;
    int Path;
};
struct ArcNode {
    int vname;
    int dist;
    struct ArcNode* Next;
};
struct VerNode {
    struct ArcNode* First;
};
struct GraphStruct {
    int vexnum, arcnum;
    struct VerNode list[MaxVertexNum];
    struct VisiteStruct Visited[MaxVertexNum];
};
struct QueueStruct {
    int capacity;
    int rear, front;
    int Array[MaxVertexNum];
};
typedef struct ArcNode* Arc;
typedef struct GraphStruct* Graph;
typedef struct QueueStruct* Queue;

void printfError();
Graph createGraph();
void initializeGraph( Graph G );
Arc createArcNode( int vname, int dist );
void BFS( Graph G, int u );
void DFS( Graph G, int u );
void Dijkstra( Graph G, int u );
void InitializeVisted( Graph G, int u );
int findMinDist( Graph G );
void enQueue( Queue q, int u );
int deQueue( Queue q );
Queue createQueue();
void initializeQueue( Queue q );

int main( void ) {

    Graph G = createGraph();
    int i = 0;
    int V1, V2, dist;
    Arc tmp = NULL;
    FILE *fp = fopen("DijkstraData.txt", "r");
    if( !fp ) {
        printfError();
    }


    for( i = 0; i < G->arcnum; i++ ) {
        fscanf(fp, "%d %d %d", &V1, &V2, &dist);

        tmp = createArcNode( V2, dist );
        tmp->Next = G->list[V1-1].First;//这段代码可能可读性比较低
        G->list[V1-1].First = tmp;
    }

    //BFS( G, 0 );
    //DFS( G, 0 );
    Dijkstra( G, 0 );

    for( i = 0; i < G->vexnum; i++ ) {
        printf("%d %d %d\n", G->Visited[i].Known, G->Visited[i].Dist, G->Visited[i].Path);
    }

    return 0;
}
void printfError() {
    printf("Space Error!");
    exit( 0 );
}
Graph createGraph() {
    Graph G = ( Graph )malloc( sizeof( struct GraphStruct ) );
    if( !G ) {
        printfError();
    }
    initializeGraph( G );

    return G;
}
void initializeGraph( Graph G ) {
    int i = 0;
    FILE *fp = fopen("NumOfVAndA2.txt", "r");
    if( !fp ) {
        printfError();
    }
    fscanf(fp, "%d %d", &G->vexnum, &G->arcnum);
    for( i = 0; i < G->vexnum; i++ ) {
        G->Visited[i].Known = false;
        G->Visited[i].Dist = INFINITY;
        G->list[i].First = NULL;
    }
}
Arc createArcNode( int vname, int dist ) {
    Arc tmp = ( Arc )malloc( sizeof(struct ArcNode) );
    if( !tmp ) {
        printfError();
    }

    tmp->vname = vname-1;
    tmp->dist = dist;
    tmp->Next = NULL;

    return tmp;
}
void BFS( Graph G, int u ) {
    Queue q = createQueue();
    int e = 0;
    Arc a = NULL;

    G->Visited[u].Known = true;
    enQueue( q, u );
    printf("%d ", u+1);

    while( q->front != q->rear ) {

        e = deQueue( q );
        a = G->list[e].First;

        while( a ) {
            if( !G->Visited[a->vname].Known ) {
                printf("%d ", (a->vname)+1);
                G->Visited[a->vname].Known = true;
                enQueue( q, a->vname );
            }
            a = a->Next;
        }
    }
}
void DFS( Graph G, int u ) {
    if( G->Visited[u].Known ) {
        return;
    }
    Arc a = G->list[u].First;

    G->Visited[u].Known = true;
    printf("%d ", u+1);

    while( a ) {
        if( !G->Visited[a->vname].Known ) {
            DFS( G, a->vname );
        }
        a = a->Next;
    }
}
void Dijkstra( Graph G, int u ) {
    InitializeVisted( G, u );
    int V;
    Arc a = NULL;

    while( 1 ) {
        V = findMinDist( G );

        if(  V == -1 ) {
            break;
        }

        G->Visited[V].Known = true;
        a = G->list[V].First;

        while( a ) {
            if( !G->Visited[a->vname].Known ) {
                if( G->Visited[a->vname].Dist > G->Visited[V].Dist + a->dist ) {
                    G->Visited[a->vname].Path = V;
                    G->Visited[a->vname].Dist = G->Visited[V].Dist + a->dist;
                }
            }
            a = a->Next;
        }


    }
}
void InitializeVisted( Graph G, int u ) {
    G->Visited[u].Known = true;
    G->Visited[u].Dist = 0;
    Arc a = G->list[u].First;

    while( a ) {
        G->Visited[a->vname].Dist = a->dist;
        G->Visited[a->vname].Path = u;
        a = a->Next;
    }
}
int findMinDist( Graph G ) {
    int V = -1;//
    int Min = INFINITY - 10;//-10 is diffrent from +10
    int i = 0;

    for( i = 0; i < G->vexnum; i++ ) {
        if( !G->Visited[i].Known && Min > G->Visited[i].Dist ) {
            V = i;
            Min = G->Visited[i].Dist;
        }
    }
    return V;
}
void enQueue( Queue q, int u ) {
    if( (q->rear+1) % MaxVertexNum == q->front ) {
        printf("IsFull");
        return;
    }
    q->rear = ( q->rear+1 ) % MaxVertexNum;
    q->Array[q->rear] = u;
}
int deQueue( Queue q ) {
    if( q->front == q->rear ) {
        printf("IsEmpty");
        return 1314521;
    }

    q->front = ( q->front+1 ) % MaxVertexNum;

    return q->Array[q->front];
}
Queue createQueue() {
    Queue q = ( Queue )malloc( sizeof(struct QueueStruct) );
    if( !q ) {
        printfError();
    }

    initializeQueue( q );

    return q;
}
void initializeQueue( Queue q ) {
    q->capacity = MaxVertexNum-1;
    q->front = q->rear = 0;
}

先用BFS或者用DFS，检查图的正确性吧，然后再继续往下写Dijkstra算法。基本上没写注释，以后看肯定看不懂，大缺点一定要改。