迪杰斯特拉算法又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。
以下是数据结构中关于迪杰斯特拉算法的操作（编程风格参考严蔚敏版数据结构）。

头文件及宏定义

#include<iostream>
#include<stdio.h>
using namespace std; 
typedef char VerTexType; 
typedef int ArcType; 
#define MaxInt 32767 
#define MVNum 100
#define ArcNum 100
#define OK 1
#define ERROR -1
#define NOTPRENODE -1
typedef int status;

说明： NOTPRENODE表示无前驱结点

图以及辅助数组的声明

bool S[MVNum];
int Path[MVNum];
int D[MVNum];
typedef struct{
	VerTexType vexs[MVNum] {'A','B','C','D','E','F'};
	ArcType arcs[MVNum][MVNum];
	int vexnum = 6,arcnum = 8;
}AMGraph; 

说明：
S[MVNum];//记录源点到终点vi的是否已被确定的最短路径长度，true表示确定false表示未确定（换个说法就是：源点到vi的边如果被选中并确定就是true，如果只是被选中并没将vi确定下来则是false）。
…
Path[MVNum];//记录源点到终点vi当前最短路径上vi的直接前驱顶点序号（如果没有前驱则为-1）。比如A（下标为0）、C（下标为2），如果将当前最短路径边选为AC（注意，只是暂选AC而不一定是确定AC，此时Path会更新而S不一定会更新），那么Path[2] = 0。
…
D[MVNum];//记录从源点到终点vi的当前最短路径长度（如果没有弧则为无穷大），其实说白了D就是一个路径权值表。 这个D的值一定要记住，是从源点开始到vi的值！是从源点开始！是从源点开始！例如，AC权值为10，CD（D下标为3）权值为20。假设过程中选择了A到D的最短路径是A->C->D，那么D[3] = 10+20=30。千万别写成那么D[3] = 20，这是错的！

举个例子：

构建有向图

status CreateSDG(AMGraph &G){//创建有向图 	
	for(int i=0;i<G.vexnum;i++){
		for(int j=0;j<G.vexnum;j++){
			if(i==j){
				G.arcs[i][j] = NOTPRENODE;
			}else
				G.arcs[i][j] = MaxInt;//初始状态全部节点之间相互不可达
		}
	}
	G.arcs[0][2]=10;G.arcs[0][4]=30;G.arcs[0][5]=100;
	G.arcs[1][2]=5;
	G.arcs[2][3]=50;
	G.arcs[3][5]=10;
	G.arcs[4][3]=20;G.arcs[4][5]=60;
	return OK; 
}

注意！有向图的邻接矩阵不一定对称（当有向图的邻接矩阵对称就是其特殊情况无向图）
老样子先生成邻接矩阵：

初始化三个辅助数组（S、Path、D）：

void initial(AMGraph &G,VerTexType v0){
	int v0i = LocateVex(G,v0);//(v0-index,源点v0的下标)
	for(int vi=0;vi<G.vexnum;vi++){
		S[vi] = false;//S初始状态为空集 
		D[vi] = G.arcs[v0i][vi];//将v0到各个终点的最短路径初始化弧上的权值（其实就是先把v0和其它点先强行直连起来） 
		if(D[vi]<MaxInt&&D[vi]!=0){
			Path[vi] = v0i;//如果v0和vi之间有弧，将vi的前置节点设为v0。 
		} else{
			Path[vi] = NOTPRENODE;
		} 
	} //for
	S[v0i] = true;//将v0加入S；
	D[v0i] = 0;//源点到源点自身的距离为0 
}

第一步：S全置false（全部未选）
第二步：把源点和其它点的边录入D中（没有边的以无穷大的形式录入）
第三步：如果源点可以到某个节点，那么该节点的先驱节点设置成源点；否则设置为无前驱节点
第四步：将源点的S置true（表示源点已被选择），源点到源点自己的距离D设为0。

迪杰斯特拉（Dijkstra）核心算法

void Dijkstra(AMGraph &G,VerTexType v0){
	int v0i = LocateVex(G,v0);
	//每次求得v0到某个顶点v的最短路径，将v加到S集 
	for(int i=1;i<G.vexnum;i++){//对其余的n-1个点进行计算 
		int min = MaxInt;
		int t;//中间变量 
		for(int j=0;j<G.vexnum;j++){
			if(!S[j]&&D[j]<min){//选出一条最短的路径，终点为j 
				t = j;//记录节点j 
				min = D[j];//当前最短路径权值是D[j] 
			}//if
		} //for
		S[t] = true;//终点t已被选择 
		for(int j=0;j<G.vexnum;j++){//更新从v0出发到其它点集合上所有最短路径长度 
			if(!S[j]&&(D[t]+G.arcs[t][j]<D[j])){//如果源点经过t点到j的距离小于源点直接到j点的距离。
				D[j] = D[t]+G.arcs[t][j];//更新D 
				Path[j] = t;//更改前驱为t。 
			}
		} 
	}//for
}

第一步：作n-1重循环（对除源点以外的节点进行遍历）
第二步：在当前路径权值表D中选出权值最短的边，记录该边的终点vi，并将该点vi的S设为已选择
第三步：将源点直接到剩下未被选择的节点vj的距离与源点经过vi节点再到未被选择的节点vj的距离进行比较（此时vi充当一个中间节点的作用），如果源点直接到vj的距离短则不作操作（初始化的时候已经操作完毕了），如果源点经过vi到达vj的距离更短，则将D[j]的距离修改为源点到vi的距离加上vi到vj的距离，那么vj点的前驱就从源点变成了vi（因为源点要经过vi到vj了）。重复第二第三步，直到选出源点分别到全部节点的最短路径（D的最后数据就是最短路径结果）。

用上例图进行手推运行过程（天蓝色表示S，绿色表示选出边但未确认终点，深蓝色表示选出边且确认终点，紫色表示该节点的前驱节点）：

1、三个辅助数组的初始化：

2、第一次大循环：AC权值最小，选择AC。C设置为已选择。
进行小循环：ACB的权值不小于AB，不进行操作；AD的权值小于ACD（下标为3）的权值，修改D【3】=AC+CD = 10+50 = 60，D的前驱结点修改为C。注意：D【3】表示为AD距离为60了。AE的权值30小于ACD权值，不进行操作；AF权值100小于ACF权值，不进行操作。

3、第二次大循环：AE权值30最短，选择AE（下标4），将E标记为已选择。
进行小循环：AEB权值不小于AB，不作操作；AED权值30+20=50小于AD权值（D下标为3），修改D【3】=50（意思是AD距离为50），D的前驱结点修改为E；AEF权值30+60=90小于AF（下标5）的权值100，修改D【5】=90（意思是AF距离为50），F前驱节点修改为为E；

4、第三次大循环：选出AED权值50最小，选出AD，D标记为已选择。
进行小循环：ADB权值不小于AB，不进行操作；ADF权值50+10=60小于AF的权值90，D【5】=60（意思是AF距离为60），将F的前驱结点设置成E；

5、第四次大循环：选出最短边AF权值60，将F标记已被选择。
进行小循环：AFB的权值不小于AB的权值，不作操作。

第五次大循环：未选择的边只有AB边了，但是由于AB的没有变（距离为无穷大），B不能被选择。
因为全部节点都被已被选择，小循环不作任何操作。程序结束（所以B的前驱结点一直都是NOTPRENODE）。

运行结果

源代码

#include<iostream>
#include<stdio.h>
using namespace std; 
typedef char VerTexType; 
typedef int ArcType; 
#define MaxInt 32767 
#define MVNum 100
#define ArcNum 100
#define OK 1
#define ERROR -1
#define NOTPRENODE -1
typedef int status;
bool S[MVNum];//记录源点到终点vi的是否已被确定的最短路径长度，true表示确定false表示未确定 
int Path[MVNum];//记录源点到终点vi当前最短路径上vi的直接前驱顶点序号（如果没有前驱则为-1）
int D[MVNum];//记录从源点到终点vi的当前最短路径长度（如果没有弧则为无穷大）。 
typedef struct{
	VerTexType vexs[MVNum] {'A','B','C','D','E','F'};
	ArcType arcs[MVNum][MVNum];
	int vexnum = 6,arcnum = 8;
}AMGraph; 

status CreateSDG(AMGraph &G){//创建有向图 	
	for(int i=0;i<G.vexnum;i++){
		for(int j=0;j<G.vexnum;j++){
			if(i==j){
				G.arcs[i][j] = NOTPRENODE;
			}else
				G.arcs[i][j] = MaxInt;//初始状态全部节点之间相互不可达
		}
	}
	G.arcs[0][2]=10;G.arcs[0][4]=30;G.arcs[0][5]=100;
	G.arcs[1][2]=5;
	G.arcs[2][3]=50;
	G.arcs[3][5]=10;
	G.arcs[4][3]=20;G.arcs[4][5]=60;
	return OK; 
}

void ShowGraph(AMGraph G){
	cout<<" ";
	for(int i=0;i<G.vexnum;i++){
		cout<<" "<<G.vexs[i];
	}
	cout<<endl;
	for(int i=0;i<G.vexnum;i++){
		cout<<G.vexs[i]<<" ";
		for(int j=0;j<G.vexnum;j++){
			if(G.arcs[i][j]==MaxInt||G.arcs[i][j]==NOTPRENODE){
				cout<<"* ";
			}else{
				cout<<G.arcs[i][j]<<" ";
			}
		}
		cout<<endl;
	}
}

int LocateVex(AMGraph G, VerTexType v){
	int i;
	for(i=0;i<G.vexnum;i++){
		if(G.vexs[i]==v){
			return i;
		}
	} 
	return ERROR;
}

void initial(AMGraph &G,VerTexType v0){
	int v0i = LocateVex(G,v0);//(v0-index,源点v0的下标)
	for(int vi=0;vi<G.vexnum;vi++){
		S[vi] = false;//S初始状态为空集 
		D[vi] = G.arcs[v0i][vi];//将v0到各个终点的最短路径初始化弧上的权值（其实就是先把v0和其它点先强行直连起来） 
		if(D[vi]<MaxInt&&D[vi]!=0){
			Path[vi] = v0i;//如果v0和vi之间有弧，将vi的前置节点设为v0。 
		} else{
			Path[vi] = NOTPRENODE;
		} 
	} //for
	S[v0i] = true;//将v0加入S；
	D[v0i] = 0;//源点到源点自身的距离为0 
}

void Dijkstra(AMGraph &G,VerTexType v0){
	int v0i = LocateVex(G,v0);
	//每次求得v0到某个顶点v的最短路径，将v加到S集 
	for(int i=1;i<G.vexnum;i++){//对其余的n-1个点进行计算 
		int min = MaxInt;
		int t;//中间变量 
		for(int j=0;j<G.vexnum;j++){
			if(!S[j]&&D[j]<min){//选出一条最短的路径，终点为j 
				t = j;//记录节点j 
				min = D[j];//当前最短路径权值是D[j] 
			}//if
		} //for
		S[t] = true;//终点t已被选择 
		for(int j=0;j<G.vexnum;j++){//更新从v0出发到其它点集合上所有最短路径长度 
			if(!S[j]&&(D[t]+G.arcs[t][j]<D[j])){//如果源点经过t点到j的距离小于源点直接到j点的距离。 
				D[j] = D[t]+G.arcs[t][j];//更新D 
				Path[j] = t;//更改前驱为t。 
			}
		} 
	}//for
}

void show(){
	cout<<"S:";
	for(int i=0;i<6;i++){
		if(S[i]){
			cout<<"T ";
		}else{
			cout<<"F ";
		}
	}
	cout<<endl;
	cout<<"D:";
	for(int i=0;i<6;i++){
		if(D[i]==MaxInt){
			cout<<"*"<<" ";
			continue;
		}
		cout<<D[i]<<" ";
	}
	cout<<endl;
	cout<<"P:";
	for(int i=0;i<6;i++){
		cout<<Path[i]<<" ";
	}
	cout<<endl; 
} 


int main(){
	AMGraph G;
	CreateSDG(G);
	initial(G,'A'); 
	cout<<"辅助数组初始化:\n";
	show();
	cout<<endl;
	Dijkstra(G,'A');
	ShowGraph(G);
	cout<<endl;
	cout<<"程序结束的辅助数组:\n";
	show();
	return 0;
} 

时间复杂度与空间复杂度

时间复杂度: 迪杰斯特拉算法的时间复杂度为 O(n×n),其中 n 表示节点个数,当图 中节点越多时,迪杰斯特拉算法花费的时间就越多。

空间复杂度: 迪杰斯特拉算法的空间复杂度也是 O(n×n),其中 n 表示节点个数,当 图中节点越多时,迪杰斯特拉算法的空间复杂度也就越大。

敬请批评指正！