迪科斯彻算法(Dijkstra)是有荷兰计算机科学家艾兹格·迪科斯彻（Edsger Wybe Dijkstra）发明的。算法解决的是有向图中单个源点到其他顶点的最短路径问题。

算法描述

这个算法是通过为每个顶点 v 保留目前为止所找到的从s到v的最短路径来工作的。初始时，原点 s 的路径长度值被赋为 0 （d[s] = 0），同时把所有其他顶点的路径长度设为无穷大，即表示我们不知道任何通向这些顶点的路径（对于 V 中所有顶点 v 除 s 外d[v] = ∞）。当算法结束时，d[v] 中储存的便是从 s 到 v 的最短路径，或者如果路径不存在的话是无穷大。 Dijkstra 算法的基础操作是边的拓展：如果存在一条从 u 到 v 的边，那么从 s 到 v 的最短路径可以通过将边（u, v）添加到尾部来拓展一条从 s 到 u 的路径。这条路径的长度是 d[u] + w(u, v)。如果这个值比目前已知的 d[v] 的值要小，我们可以用新值来替代当前 d[v] 中的值。拓展边的操作一直执行到所有的 d[v] 都代表从 s 到 v 最短路径的花费。这个算法经过组织因而当 d[u] 达到它最终的值的时候每条边（u, v）都只被拓展一次。

算法维护两个顶点集 S 和 Q。集合 S 保留了我们已知的所有 d[v] 的值已经是最短路径的值顶点，而集合 Q 则保留其他所有顶点。集合S初始状态为空，而后每一步都有一个顶点从 Q 移动到 S。这个被选择的顶点是 Q 中拥有最小的 d[u] 值的顶点。当一个顶点 u 从 Q 中转移到了 S 中，算法对每条外接边 (u, v) 进行拓展。

算法实现

算法实现起来比较简单，当然这得归功于算法作者。

一、邻接矩阵实现

/*图的邻接矩阵存储*/
typedef int VertexType;
typedef int EdgeType;
#define MAXVEX 100
#define INFI 65535

typedef struct 
{
	VertexType vexs[MAXVEX];           /*顶点表*/
	EdgeType matrix[MAXVEX][MAXVEX];   /*邻接矩阵*/
	int numVertexes;          /*顶点数*/
	int numEdges;             /*边数*/
}Graph;
/*创建一个邻接矩阵有向图*/
Graph* CreateDiGraph()
{
	Graph *pGragh = new Graph;
	if (NULL == pGragh)
		return NULL;

	cout << "输入顶点数和边数：" << endl;
	cin >> pGragh->numVertexes >> pGragh->numEdges;

	for (int i = 0; i < pGragh->numVertexes; ++i)/*建立顶点表*/
		(pGragh->vexs)[i] = i;
	for (int i = 0; i < pGragh->numVertexes; ++i)/*邻接矩阵初始化*/
	{
		for (int j = 0; j < pGragh->numVertexes; ++j)
		{
			(pGragh->matrix)[i][j] = INFI;
			if (i == j)
				(pGragh->matrix)[i][j] = 0;
		}
	}
	for (int k = 0; k < pGragh->numEdges; ++k)
	{
		int i, j, w;
		cout << "输入边<vi,vj>上的下标i，下标j和权重w：" << endl;
		cin >> i >> j >> w;
		(pGragh->matrix)[i][j] = w;//清楚上面输入的顺序，有向边的开始点和终点
	}
	return pGragh;
}
/*图的邻接矩阵存储方式Dijkstra算法实现
该算法的目的是：找到图中给定起始点到其余顶点的最短距离*/
/*传参：dist为图pGraph中的起始顶点start到图中各个顶点的最短距离
dist为与图顶点数等值大小的数组，作为返回值
参数有效性有调用者保证*/
void Dijkstra(Graph *pGraph, int dist[], int start)
{
	bool *visited = new bool[pGraph->numVertexes]();//建立踪迹表
	visited[start] = true;//记录已经访问的顶点
	
	for (int i = 0; i < pGraph->numVertexes; ++i)
	{
		dist[i] = (pGraph->matrix)[start][i];//记录起始点start到各顶点的距离
	}

	int index;
	for (int i = 1; i < pGraph->numVertexes; ++i)
	{
		int mincost = INFI;
		for (int j = 0; j < pGraph->numVertexes; ++j)
		{
			if (!visited[j] && dist[j] < mincost)//选出起始点到其余顶点中的最小距离的那个顶点
			{
				mincost = dist[j];
				index = j;//记录该最小距离顶点
			}
		}

		visited[index] = true;//标记为已经访问过
		for (int j = 0; j < pGraph->numVertexes; ++j)
		{
			/*d[u] + w(u,v) < d[v] 就更新为最小距离为d[u]+w(u,v)*/
			if (!visited[j] && (dist[index] + (pGraph->matrix)[index][j]) < dist[j])
				dist[j] = dist[index] + (pGraph->matrix)[index][j];
			//dist 中保存的始终都是起始顶点start到图其余各顶点间的距离(访问过的就更新为最小)
		}
	}
}

需要注意的是，上面的Dijkstra算法得到的只是起始点到各个顶点的最小距离值，并没有记录其到达的最短路径。如果要计算某两个顶点之间的最短路径的话，可在更新最小距离的时候把中间顶点保存即可。实现比较简单就不贴出来了。

二、邻接表实现
相信经过了上面，举一反三的你也会很容易把邻接表的Dijkstra 算法实现出来。（懒啊，图片来源于《大话数据结构》，向作者致敬）

typedef int VertexType;
typedef int EdgeType;
#define INFI 65535

/*下面构成一个链式哈希表结构*/
/*边表结点*/
typedef struct AdjNode
{
	int adjvex;  //边的终点
	int weight;  //边的权重
	struct AdjNode *next;  //指向下一个邻接点
}AdjNode;

/*顶点表结点*/
typedef struct VertexNode
{
	VertexType data;   //顶点信息
	AdjNode *pFfirstedge;  //边表头指针
}VertexNode;

/*图结点*/
typedef struct Graph
{
	VertexNode *AdjArray;   //指向顶点表
	int numVertexes;
	int numEdges;
}Graph;

Graph* CreateDiGraph()
{
	Graph *pGraph = new Graph;
	AdjNode *pNode = NULL;
	if (NULL == pGraph)
		return NULL;

	cout << "输入顶点数和边数：" << endl;
	cin >> pGraph->numVertexes >> pGraph->numEdges;

	pGraph->AdjArray = new VertexNode[pGraph->numVertexes]();//创建并初始化为0
	if (NULL == pGraph->AdjArray)
	{
		delete pGraph;
		return NULL;
	}

	/*建立顶点信息表*/
	for (int i = 0; i < pGraph->numVertexes; ++i)
	{
		/*这里默认顶点从0到pGraph->numVertexes，可根据需要修改
		如：
		cout << "输入顶点信息" << endl;
		cin >> (pGraph->AdjArray)[i].data;
		*/
		(pGraph->AdjArray)[i].data = i;
	}

	/*建立边表*/
	for (int k = 0; k < pGraph->numEdges; ++k)
	{
		int i, j, w;
		cout << "输入边<vi,vj>上的下标i，下标j和权重w：" << endl;
		cin >> i >> j >> w;

		pNode = new AdjNode;
		if (NULL == pNode)
		{
			delete[] pGraph->AdjArray;
			delete pGraph;
			return NULL;
		}
		pNode->adjvex = j;
		pNode->weight = w;
		pNode->next = (pGraph->AdjArray)[i].pFfirstedge;//类链式哈希表插入操作，新节点插入到链表头结点
		(pGraph->AdjArray)[i].pFfirstedge = pNode;
	}
	return pGraph;
}

/*这里着重阐述算法实现，参数的有效性由调用者保证*/
/*dist中保存的则是起始点start到图中各顶点的最小距离*/
void Dijkstra(Graph *pGraph,int dist[], int start)
{
	bool *visited = new bool[pGraph->numVertexes]();
	visited[start] = true;

	/*不同于邻接矩阵，注意这里的初始化距离*/
	for (int i = 0; i < pGraph->numVertexes; ++i)
		dist[i] = INFI;
	dist[start] = 0;

	/*记录起始点到各邻接点的距离*/
	for (AdjNode *ptmp = (pGraph->AdjArray)[start].pFfirstedge; ptmp; ptmp = ptmp->next)
	{
		dist[ptmp->adjvex] = ptmp->weight;
	}

	int index;
	for (int i = 1; i < pGraph->numVertexes; ++i)
	{
		int mincost = INFI;
		/*选择其中最小的距离的顶点*/
		for (int j = 0; j < pGraph->numVertexes; ++j)
		{
			if (!visited[j] && dist[j] < mincost)
			{
				mincost = dist[j];
				index = j;
			}
		}

		/*以该顶点x为中间点，找到下一个点y，如果起始点start到中间点x的距离加上x到y的距离小于start到y的距离，则更新*/
		/*换言之，如果直接从北京到深圳用的钱比从先从北京到上海，再从上海转机到深圳要多，那么就选择后面这个方案*/
		visited[index] = true;
		for (AdjNode *ptmp = (pGraph->AdjArray)[index].pFfirstedge; ptmp; ptmp = ptmp->next)
		{
			if (!visited[ptmp->adjvex] && (dist[index] + ptmp->weight) < dist[ptmp->adjvex])
				dist[ptmp->adjvex] = dist[index] + ptmp->weight;
		}
	}
}

可以看出迪科斯彻算法的时间复杂度为O(n^2)，对于邻接矩阵空间复杂度为O(n^2)。

图的邻接表存储实现： http://blog.csdn.net/wenqian1991/article/details/24667287

图的邻接矩阵存储实现：http://blog.csdn.net/wenqian1991/article/details/47123807

图的DFS和BFS：     http://blog.csdn.net/wenqian1991/article/details/24812393