DijkstraAlgorithm迪杰斯特拉算法（最短路径）

package dijkstra;

import java.util.Arrays;

public class DijkstraAlgorithm {

public static void main(String[] args) {

// TODO Auto-generated method stub

char[] vertex = {'A','B','C','D','E','F','G'};

int [][] matrix = new int[vertex.length][vertex.length];

final int N = 65535;

matrix[0]=new int[]{N,5,7,N,N,N,2};

matrix[1]=new int[]{5,N,N,9,N,N,3};

matrix[2]=new int[]{7,N,N,N,8,N,N};

matrix[3]=new int[]{N,9,N,N,N,4,N};

matrix[4]=new int[]{N,N,8,N,N,5,4};

matrix[5]=new int[]{N,N,N,4,5,N,6};

matrix[6]=new int[]{2,3,N,N,4,6,N};

Graph graph = new Graph(vertex,matrix);

graph.showGraph();

graph.dsj(6);

graph.showDijkstra();

}

}

class Graph{

private char[] vertex; //顶点数组

private int[][] matrix; //邻接矩阵

private VisitedVertex vv; //已经访问过的顶点的集合

public Graph(char[] vertex,int[][] matrix) {

this.vertex = vertex;

this.matrix = matrix;

}

public void showGraph() {

for(int [] link: matrix) {

System.out.println(Arrays.toString(link));

}

}

//迪杰斯特拉算法实现

/**迪杰斯特拉算法

*

* @param index 表示出发顶点对应的下标

*/

public void dsj(int index) {

vv = new VisitedVertex(vertex.length,index);

update(index);//更新index下标顶点到周围顶点的距离和周围顶点的前驱节点

for(int j=1;j<vertex.length;j++) {

index = vv.updateArr();//选择并返回新的访问顶点

update(index);//更新index下标顶点到周围顶点的距离和周围顶点的前驱节点

}

}

//更新index下标顶点到周围顶点的距离和周围顶点的前驱节点

public void update(int index) {

int len=0;

//遍历邻接矩阵的matrix[index]行

for(int j=0;j<matrix[index].length;j++) {

//len的含义：出发顶点到index顶点的距离+index顶点的到j顶点的距离。 例如：A-B-C A到C的距离为 A到B的距离+B到C的距离

len = vv.getDis(index)+matrix[index][j];

//若j顶点未被访问，且len小于出发顶点到j顶点的距离，就需要更新

if(!vv.in(j)&&len<vv.getDis(j)) {

vv.updatePre(j, index);//更新j顶点的前驱节点

vv.updateDis(j, len);//更新出发顶点到j顶点的距离

}

}

}

public void showDijkstra() {

vv.show();

}

}

class VisitedVertex{

//记录顶点是否已访问0为未访问，1为以访问

public int[] already_arr;

//记录下表对应的值为的前一个顶点的下标。就是0代表A，per_visited[0]为6，那么A的上一个顶点为G

public int[] pre_visited;

//记录出发顶点到其他所有顶点的距离

public int[] dis;

public VisitedVertex(int length,int index){

this.already_arr = new int[length];

this.pre_visited = new int[length];

this.dis = new int[length];

//初始化dis数组

Arrays.fill(dis, 65535);

this.already_arr[index] = 1;//设置出发顶点被访问过

this.dis[index] = 0;

}

/**

* 功能：判断index定点是否被访问过

* @param index

* @return 被访问过返回true,为被访问过返回false

*/

public boolean in(int index) {

return already_arr[index]==1;

}

/**

* 功能：更新出发顶点到index顶点的距离

* @param index

* @param length

*/

public void updateDis(int index,int length) {

dis[index] = length;

}

/**

* 功能：更新pre这个节点的前驱为index的节点

* @param pre

* @param index

*/

public void updatePre(int pre,int index) {

pre_visited[pre] = index;

}

/**

* 功能：返回出发顶点到index这个顶点的距离

* @param index

* @return

*/

public int getDis(int index) {

return dis[index];

}

/**

* 功能：继续选择并返回新访问的顶点，例如访问完G后,A作为新访问的顶点（注意不是出发顶点）

* @return

*/

public int updateArr() {

int min = 65535,index=0;

for(int i=0;i<already_arr.length;i++) {

if(already_arr[i]==0&&dis[i]<min) {

min = dis[i];

index = i;

}

}

already_arr[index]=1;//更新一个标志一个

return index;

}

public void show() {

System.out.println("==================");

for(int i:already_arr) {

System.out.print(i+" ");

}

System.out.println();

for(int i:pre_visited) {

System.out.print(i+" ");

}

System.out.println();

for(int i:dis) {

System.out.print(i+" ");

}

System.out.println();

char[] vertex = {'A','B','C','D','E','F','G'};

int count = 0;

for(int i:dis) {

if(i!=65535) {

System.out.print(vertex[count]+"("+i+")");

}else {

System.out.print("N ");

}

count++;

}

System.out.println();

}

}