图--Dijkstra算法

声明：dijkstra.h文件 

#pragma once
#ifndef DIJKSTRA_H
#define DIJKSTRA_H
#define X 999
#define Max 6
#define Nopath -1
#include <stdio.h>
#include "DIJKSTRA.h" 
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

//图
//顶点
typedef struct node
{
	int path; //上一站顶点 
	int visited; //有没有读取完成(标记)
	int distance; //距离 
	char name;
}Node;
typedef Node* TABLE;

void InitializeTable(int start, TABLE T[]); //初始化表,该表用于保存各个顶点的数据


//优先队列
typedef struct PriorityQueue
{
	int size; //当前优先队列里顶点数 
	int capacity; //队列容量 
	TABLE element[Max];
}Queue;
typedef Queue* QUEUE;

QUEUE InitializeQueue(int capacity); //优先队列初始化
void enqueue(QUEUE Q, TABLE K); //入队
int dequeue(QUEUE Q); //出队
void Dijkstra(int const(*map)[Max], int start, TABLE T[]); //迪杰斯特拉算法
void ShowTable(TABLE T[]); //打印表中数据  


#endif

源代码：

#include "DIJKSTRA.h"

//声明一个图
const int map[6][6] = {
				/*A*/	{0,5,1,X,X,X},
				/*B*/	{5,0,2,1,X,X},
				/*C*/	{1,2,0,4,8,X},
				/*D*/	{X,1,4,0,3,6},
				/*E*/	{X,X,8,3,0,X},
				/*F*/	{X,X,X,6,X,0},
};

//初始化表,该表用于保存各个顶点的数据
void InitializeTable(int start, TABLE T[])
{
	int i;
	for (i = 0; i < Max; i++)
	{
		T[i] = (Node*)malloc(sizeof(Node));
		T[i]->visited = 0;
		T[i]->path = Nopath;
		T[i]->distance = X;
		T[i]->name = 65 + i;//ASCII A B C  D E F 
	}
	T[start]->distance = 0;
}

//初始化优先队列
QUEUE InitializeQueue(int capacity)
{
	QUEUE Q;
	Q = (Queue*)malloc(sizeof(Queue));
	Q->capacity = capacity;
	Q->size = 0;

	for (int i = 1; i < Max; i++)
	{
		Q->element[i] = NULL;
	}

	Q->element[0] = (Node*)malloc(sizeof(Node));
	Q->element[0]->distance = 0;

	return Q;
}

//入队
void enqueue(QUEUE Q, TABLE K)
{
	int i, hole;

	if (K->path == Nopath)
	{
		Q->size++;
		hole = Q->size;
	}
	else
	{
		i = 1;

		while (K->name != Q->element[i]->name && Q->element[i] != NULL)
		{
			i++;
		}

		hole = i;
	}

	i = hole / 2;

	while (K->distance < Q->element[i]->distance)
	{
		Q->element[hole] = Q->element[i];
		hole = i;
		i = i / 2;
	}

	Q->element[hole] = K;
}

//出队
int dequeue(QUEUE Q)
{
	TABLE OUT;
	int hole = 1, child = 2, last = Q->size;
	OUT = Q->element[1];
	Q->size--;

	while (child <= Q->size && Q->element[child]->distance < Q->element[last]->distance)
	{
		if (Q->element[child]->distance > Q->element[child + 1]->distance)
		{
			child++;
		}

		Q->element[hole] = Q->element[child];
		hole = child;
		child = hole * 2;
	}

	Q->element[hole] = Q->element[last];
	Q->element[last] = NULL;

	return OUT->name - 65;
}

//迪杰斯特拉算法
void Dijkstra(int const(*map)[Max], int start, TABLE T[])
{

	int current;
	InitializeTable(start, T);
	QUEUE Q;
	Q = InitializeQueue(Max);
	enqueue(Q, T[start]);

	while (Q->size != 0)
	{
		current = dequeue(Q);

		for (int i = 0; i < Max; i++)
		{
			int EdgeLength = map[current][i];

			if (EdgeLength != 0 && EdgeLength != X && T[i]->visited == 0)
			{
				if (T[i]->distance > EdgeLength + T[current]->distance); //贪婪的判断
				{
					T[i]->distance = EdgeLength + T[current]->distance;
					enqueue(Q, T[i]);
					T[i]->path = current;
				}
			}
		}

		T[current]->visited = 1;
	}
}

//打印表中数据
void ShowTable(TABLE T[])
{
	int i;
	printf("name	visited		dis	  path\n");
	for (i = 0; i < Max; i++)
	{
		printf("%c:	%d		%d	  %c\n", T[i]->name, T[i]->visited, T[i]->distance, T[i]->path + 65);
	}
}


//主函数
int main(void)
{
	TABLE T[Max];
	Dijkstra(map, 0, T);
	ShowTable(T);

	return 0;
}