数据结构 Dijkstra(迪杰斯特拉)算法
Dijkstra(迪杰斯特拉)算法
是典型的单源最短路径算法,用于计算一个节点到其他所有节点的最短路径,该算法要求图中不存在负权边。
主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止。
算法思想: 图 G=(V,E) 中,假设每条边E[i]的长度为w[i],找到由顶点V0到其余各点的最短路径
设G=(V,E)是一个带权有向图,把图中顶点集合V分成两组:
第一组为已求出最短路径的顶点集合(用S表示,初始时S中只有一个源点,以后每求得一条最短路径 , 就将加入到集合S中,直到全部顶点都加入到S中,算法就结束了),
第二组为其余未确定最短路径的顶点集合(用U表示),
按最短路径长度的递增次序依次把第二组的顶点加入S中。在加入的过程中,总保持从源点v到S中各顶点的最短路径长度不大于从源点v到U中任何顶点的最短路径长度。
每个顶点对应一个距离:
S中的顶点的距离是从v到此顶点的最短路径长度,
U中的顶点的距离是从v到此顶点只包括S中的顶点为中间顶点的当前最短路径长度。
算法步骤:
1、初始化:
S只包含源点,即S={v},v的距离为0。
U包含除v外的其他顶点,即:U={其余顶点},
若v与U中顶点u有边,则
import java.io.IOException;
import java.util.Scanner;
public class MatrixUDG2 {
private int mEdgNum; // 边的数量
private char[] mVexs; // 顶点集合
private int[][] mMatrix; // 邻接矩阵
private static final int INF = 100;//Integer.MAX_VALUE; // 最大值
public MatrixUDG2(char[] vexs, int[][] matrix) {
int vlen = vexs.length; // 初始化"顶点数"和"边数"
mVexs = new char[vlen]; // 初始化"顶点"
for (int i = 0; i < mVexs.length; i++)
mVexs[i] = vexs[i];
mMatrix = new int[vlen][vlen]; // 邻接矩阵: 初始化"边" mMatrix[i][j]=1,则表示"顶点i(即mVexs[i])"和"顶点j(即mVexs[j])"是邻接点;mMatrix[i][j]=0,则表示它们不是邻接点
for (int i = 0; i < vlen; i++)
for (int j = 0; j < vlen; j++)
mMatrix[i][j] = matrix[i][j];
// 统计"边"
mEdgNum = 0;
for (int i = 0; i < vlen; i++)
for (int j = i+1; j < vlen; j++)
if (mMatrix[i][j]!=INF)
mEdgNum++;
}
//返回顶点v的第一个邻接顶点的索引,失败则返回-1
private int firstVertex(int v) {
if (v<0 || v>(mVexs.length-1))
return -1;
for (int i = 0; i < mVexs.length; i++)
if (mMatrix[v][i]!=0 && mMatrix[v][i]!=INF)
return i;
return -1;
}
// 返回顶点v相对于w的下一个邻接顶点的索引,失败则返回-1
private int nextVertex(int v, int w) {
if (v<0 || v>(mVexs.length-1) || w<0 || w>(mVexs.length-1))
return -1;
for (int i = w + 1; i < mVexs.length; i++)
if (mMatrix[v][i]!=0 && mMatrix[v][i]!=INF)
return i;
return -1;
}
// 返回顶点v相对于w的下一个邻接顶点的索引,失败则返回-1
private int nextVertexs(int v) {
if (v<0 || v>(mVexs.length-1))
return -1;
for (int i=0; i < mVexs.length; i++) {
if (mMatrix[v][i]!=0 && mMatrix[v][i]!=INF) {
System.out.print("邻接点"+mVexs[i]+"权重("+mMatrix[v][i]+")");
}
}
return -1;
}
//获取图中的边
private void getEdges() {
System.out.print("edges = "+mEdgNum);
System.out.println();
for (int i=0; i < mVexs.length; i++) {
for (int j=0; j < mVexs.length; j++) {
if (mMatrix[i][j]!=INF && mMatrix[i][j] != 0) {
System.out.println("结点"+mVexs[i]+"和结点"+mVexs[j]+"的边,权重"+mMatrix[i][j]);
}
}
}
System.out.println();
}
/*
* Dijkstra最短路径。
* 即,统计图中"顶点vs"到其它各个顶点的最短路径。
* vs -- 起始顶点(start vertex)。即计算"顶点vs"到其它顶点的最短路径。
* prev -- 前驱顶点数组。即,prev[i]的值是"顶点vs"到"顶点i"的最短路径所经历的全部顶点中,位于"顶点i"之前的那个顶点。
* dist -- 长度数组。即,dist[i]是"顶点vs"到"顶点i"的最短路径的长度。
*/
public void dijkstra(int vs, int[] prev, int[] dist) {
// flag[i]=true表示"顶点vs"到"顶点i"的最短路径已成功获取
boolean[] flag = new boolean[mVexs.length];
// 初始化
for (int i = 0; i < mVexs.length; i++) {
flag[i] = false; // 顶点i的最短路径还没获取到。
prev[i] = 0; // 顶点i的前驱顶点为0。
dist[i] = mMatrix[vs][i]; // 顶点i的最短路径为"顶点vs"到"顶点i"的权。
}
// 对"顶点vs"自身进行初始化
flag[vs] = true;
dist[vs] = 0;
// 遍历mVexs.length-1次;每次找出一个顶点的最短路径。
int k=0;
for (int i = 1; i < mVexs.length; i++) {
// 寻找当前最小的路径;
// 即,在未获取最短路径的顶点中,找到离vs最近的顶点(k)。
int min = INF;
for (int j = 0; j < mVexs.length; j++) {
if (flag[j]==false && dist[j]<min) {
min = dist[j];
k = j;
//System.out.println("min = "+min+", k ="+k);
}
}
// 标记"顶点k"为已经获取到最短路径
flag[k] = true;
// 修正当前最短路径和前驱顶点
// 即,当已经"顶点k的最短路径"之后,更新"未获取最短路径的顶点的最短路径和前驱顶点"。
for (int j = 0; j < mVexs.length; j++) {
int tmp = (mMatrix[k][j]==INF ? INF : (min + mMatrix[k][j]));
if (flag[j]==false && (tmp<dist[j]) ) {
dist[j] = tmp;
//System.out.println("dist[j] = "+dist[j]+", j = "+j);
prev[j] = k;
}
}
}
// 打印dijkstra最短路径的结果
System.out.printf("dijkstra(%c): \n", mVexs[vs]);
for (int i=0; i < mVexs.length; i++)
System.out.printf("shortest(%c, %c)=%d\n", mVexs[vs], mVexs[i], dist[i]);
}
public static void main(String[] args) {
char[] vexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
int matrix[][] = {
/*A*//*B*//*C*//*D*//*E*//*F*//*G*/
/*A*/ { 0, 12, INF, INF, INF, 16, 14},
/*B*/ { 12, 0, 10, INF, INF, 7, INF},
/*C*/ { INF, 10, 0, 3, 5, 6, INF},
/*D*/ { INF, INF, 3, 0, 4, INF, INF},
/*E*/ { INF, INF, 5, 4, 0, 2, 8},
/*F*/ { 16, 7, 6, INF, 2, 0, 9},
/*G*/ { 14, INF, INF, INF, 8, 9, 0}};
int length = vexs.length;
int i=0, j;
System.out.print("结点表: \n");
for(char label:vexs) {
System.out.print("结点"+i+", 标识"+label+"\n");
i++;
}
System.out.print("\n");
System.out.print("邻接矩阵: \n");
for(i=0; i<length; i++){
for(j=0; j<length; j++) {
System.out.printf("%2d ", matrix[i][j]);
}
System.out.print("\n");
}
System.out.print("\n");
MatrixUDG2 pG;
pG = new MatrixUDG2(vexs, matrix);
//pG.getEdges();
for(i=0; i<length; i++){
//System.out.printf("顶点%d邻接点%d\n", i, pG.firstVertex(i));
System.out.print("顶点"+vexs[i]);
pG.nextVertexs(i);
System.out.print("\n");
}
System.out.print("\n");
int[] prev = new int[pG.mVexs.length];
int[] dist = new int[pG.mVexs.length];
// dijkstra算法获取"第4个顶点"到其它各个顶点的最短距离
pG.dijkstra(3, prev, dist);
}
}