Dijkstra求最短路径

代码里面注释很详细，不适合分析，就把代码贴出来吧，该路径数组dis还可以从数据库中取出来。

package com.yuan.test;

import java.util.Stack;

public class Dijkstra {
    static int n = 7;// 顶点数
    static int[][] dis = new int[n][n];
    static int[] dist = new int[n];//dist[i]表示源点（start）到i顶点的距离
    static int[] path = new int[n];//path记录最短路径上从start到i的前一个顶点
    static int count = 0;
    static boolean flag = false;
    public static void main(String[] args) {
        dis[0][1] = 2;
        dis[1][2] = 3;
        dis[2][3] = 4;
        dis[4][6] = 5;
        int start = 6;
        int goal = 0;
        if(start > goal){
            flag = true;
            int temp = start;
            start = goal;
            goal = temp;
        }
        DijkstraPath(dis, dist, path, start);
        //array保存一次经过的点
        int[] array =showPath(path, goal, start);
        if(array.length == 1){
            if(array[0] != start)
                System.out.print("该点不能到达终点");
            if(start == goal)
                System.out.print("该点就是终点");
        }
        else{
            System.out.print("最短路径为：");
            for(int i = 0;i < array.length;i++)
                System.out.print(array[i]+" ");
            System.out.println();
            System.out.println("最短距离为："+dist[goal]);
        }

    }
    static int[] DijkstraPath(int[][] dis, int[] dist, int[] path, int start) // start表示源顶点
    {
        int i, j, k;
        boolean[] goalisited = new boolean[n];
        for (i = 0; i < n; i++) // 初始化
        {
            if (dis[start][i] > 0 && i != start) {
                dist[i] = dis[start][i];// dist[i]表示源点（start）到i顶点的距离
                path[i] = start; // path记录最短路径上从start到i的前一个顶点
            } else {
                dist[i] = Integer.MAX_VALUE; // 若i不与start直接相邻，则权值置为无穷大
                path[i] = -1;
            }
            goalisited[i] = false;
            path[start] = start;
            dist[start] = 0;
        }
        goalisited[start] = true;
        for (i = 1; i < n; i++) // 循环扩展n-1次
        {
            int min = Integer.MAX_VALUE;
            int u = 0;
            for (j = 0; j < n; j++) // 寻找未被扩展的权值最小的顶点
            {
                if (goalisited[j] == false && dist[j] < min) {
                    min = dist[j];
                    u = j;
                }
            }
            goalisited[u] = true;
            for (k = 0; k < n; k++) // 更新dist数组的值和路径的值
            {
                if (goalisited[k] == false && dis[u][k] > 0
                        && min + dis[u][k] < dist[k]) {
                    dist[k] = min + dis[u][k];
                    path[k] = u;
                }
            }
        }
        return path;
    }

    static int[] showPath(int[] path, int goal, int start) // 打印最短路径上的各个顶点
    {
        Stack<Integer> s = new Stack<Integer>();
        int i = 0;
        while (goal != start) {
            s.push(goal);
            if(path[goal] == -1){
                int array[] = new int[1];
                if(flag == false)
                    array[0] = start;
                else {
                    array[0] = goal;
                }
                return array;
            }
            goal = path[goal];
        }
        s.push(goal);
        int[] array = new int[s.size()];
        if(s.size() == 1){
            array[0] = start;
            return array;
        }
        if(flag == false){
            //System.out.print("goal>start的情况：");
            while (!s.empty()){
                array[i] = s.pop();
                //System.out.print(array[i]+" ");
                i++;
            }
        }else {
            //System.out.print("goal<start的情况：");
            i = s.size()-1;
            while(!s.empty()){
                array[i] = s.pop();
                i--;
            }
        }
        return array;
    } 
}