迪杰特斯拉算法的实现

/*=============================================
    功能：实现dijkstra算法（单源点路径最短问题）
===============================================*/

#include <stdio.h>
#include <stdlib.h>

#define MAX_FLOAT_NUM 100                      /* 定义最大浮点数 */
#define TRUE 1
#define FALSE 0
#define NUM_V    8                                  /* 邻接表顶点个数 */

struct adj_list                                   /* 邻接表节点定义 */  
{
    int v_num;                                      /* 节点编号定义 */
    int len;                                      /* 邻接定点与该顶点的距离 */
    struct adj_list *next;                          /* 下一个邻接顶点 */
};

typedef struct adj_list NODE;
typedef int BOOL;

void dijkstra(int n, int u);
void init();                                      /* 创建有向图的邻接表 */
void free_memory();                                  /* 释放内存空间 */
void display();                                      /* 输出建立的邻接表 */
void display_path(int path[], int distance[], int vetex);      /* 最短路径以及距离 */

NODE node[NUM_V];                                  /* 头节点数组 */

int array_index[15] = {0,0,0,1,1,2,2,2,2,3,4,5,5,6,6};
int array_length[15] = {1,4,4,2,9,3,6,3,4,7,1,2,5,1,3};
int array_v_num[15] = {1,2,3,2,4,3,4,5,6,6,7,4,7,5,7};

int p[23];
int d[23];

void main()
{
    init();
    display();
    dijkstra(23, 0);
    free_memory();
}
/*=====================================================
    功能：实现dijkstra算法
    输入：n个节点，源点u
    输出：顶点到u的距离d[],p[]前方顶点编号
=======================================================*/
void dijkstra(int n, int u)
{
    int i = 0,j,t;
    int temp = MAX_FLOAT_NUM;
    BOOL *s = malloc(n * sizeof(BOOL));
    NODE *pnode = node[u].next;            /* 源点邻接表 */

    if(pnode == NULL)
        return;                
                
    for(i = 0; i < n; i++)                    /* 初始化d[] */
    {
        d[i] = MAX_FLOAT_NUM;
        p[i] = -1;
        s[i] = FALSE;
    }
    s[u] = TRUE;
    d[u] = 0;
    p[u] = -1;

    while(pnode)                            /* 初始化与u点临界点的距离 */
    {
        if(pnode->len < d[pnode->v_num])
        {
            d[pnode->v_num] = pnode->len;
            p[pnode->v_num] = u;
        }
        pnode = pnode->next;
    }
    for(i = 0; i < n; i++)                    
    {
        temp = MAX_FLOAT_NUM;
        t = u;
        for(j = 0; j < n; j ++)                /* 选出d[]中最短路径 */
        {
            if(!s[j] && d[j] < temp)
            {
                t = j;
                temp = d[j];
            }
        }
        if(t == u)
            break;                          /* 找不出最短路径 */
        s[t] = TRUE;
        display_path(p, d, t);                /* 显示最短路径和距离 */
        pnode = node[t].next;                /* 更新与t相连的顶点与原顶点的距离d */
        while(pnode)
        {
            if(!s[pnode->v_num] && (d[pnode->v_num] > (pnode->len + d[t])))
            {
                d[pnode->v_num] = pnode->len + d[t];
                p[pnode->v_num] = t;
            }
            pnode = pnode->next;
        }
    }
    free(s);
}

void init()
{
    int i = 0;
    NODE *end;
    for(; i < 8; i ++)                    /* 8个头结点 */
    {
        node[i].v_num = i;
        node[i].len = 0;
        node[i].next = NULL;
    }
    for(i = 0; i < 15; i ++)
    {
        NODE *temp = malloc(sizeof(NODE));  /* 创建一个节点 */

        temp->len = array_length[i];
        temp->next = NULL;
        temp->v_num = array_v_num[i];

        end = &node[array_index[i]];

        while(end->next != NULL)                  /* 找到邻接表最后一个顶点 */
        {
            end = end->next;
        }
        end->next = temp;
    }
}
//输出邻接表内容
void display()
{
    int i = 0;
    NODE *end;
    for(; i < 8; i ++)
    {
        end = &node[i];
        while(end != NULL)
        {
            printf("%d %d\t", end->v_num, end->len);    
            end = end->next;
        }
        printf("\n");
    }
}
//释放邻接表中动态分配的内存空间
void free_memory()
{
    NODE *end,*end_behind;
    int i =0;
    for(; i < 8; i ++)
    {
        end = node[i].next;
        while(end)
        {
            end_behind = end->next;
            free(end);
            end = end_behind;
        }
        free(end);
    }
}
void display_path(int path[], int distance[], int vtex)      /* 最短路径以及距离 */
{
    int i = vtex;
    printf("path%d:", vtex);

    while(p[i] != -1)
    {
        printf("%d ", p[i]);
        i = p[i];
    }
    printf("distance   %d\n", distance[vtex]);
}