java数据结构和算法------图(最短路径Dijkstra)

package iYou.neugle.graph;

import java.util.ArrayList;
import java.util.List;

//创建图过程的代码在图的那篇博文中，此处直接使用
public class Dijkstra {
    private MyGraph1 graph;
    private int start;
    private int maxNum;
    private int[] distance;// 起始点到终点距离
    private int[] point;// 除起始点的其他点的集合
    private String[] path;// 起始点到终点的路径
    private List<Integer> s = new ArrayList<Integer>();// 点的集合

    public Dijkstra(MyGraph1 graph, int start) {
        this.graph = graph;
        this.start = start - 1;
        this.maxNum = this.graph.getGraph().maxNum;
        distance = new int[this.maxNum - 1];
        point = new int[this.maxNum - 1];
        path = new String[this.maxNum - 1];
    }

    // 初始化最小距离数组
    private void Init() {
        for (int i = 0; i < this.maxNum - 1; i++) {
            this.distance[i] = Integer.MAX_VALUE;
            if (i >= this.start) {
                this.point[i] = i + 1;
            } else {
                this.point[i] = i;
            }
        }
    }

    public void DijkstraCore() {
        this.Init();
        // 首先将起始节点加入到集合s中
        this.s.add(this.start);
        // 初始化中间节点u
        int u = this.start;
        // 若果s集合达到maxNum则终止
        while (s.size() < this.maxNum) {
            int[][] edges = this.graph.getGraph().edge;
            boolean b = false;
            for (int i = 0; i < edges[u].length; i++) {
                // 如果开始节点和中间节点不连通则不进行任何操作(排除开始节点)
                if (edges[this.start][u] == 0 && u != this.start) {
                    break;
                }
                // 节点到起始点的距离是不用求的
                if (i == this.start) {
                    b = true;
                    continue;
                }
                int x;
                // 如果在起始节点之后的节点需要i--
                if (b == false) {
                    x = i;
                } else {
                    x = i - 1;
                }
                // 如果有路径则计算
                if (edges[u][i] != 0) {
                    int temp = edges[this.start][u] + edges[u][i];
                    if (temp < this.distance[x]) {
                        this.distance[x] = temp;
                        if (this.start == u) {
                            this.path[x] = (this.start + 1) + "->" + (i + 1);
                        } else {
                            this.path[x] = (this.start + 1) + "->" + (u + 1)
                                    + "->" + (i + 1);
                        }
                    }
                }
            }
            // 找到下一次的中间节点
            u = this.Function();
            // 将中间点加入到集合s中
            this.s.add(u);
        }
        this.Print();
    }

    // 功能函数:找到此时distance数组中的最小值(最小值的条件是不在s中的最小值)
    private int Function() {
        int u = Integer.MAX_VALUE;
        int k = -1;
        for (int i = 0; i < this.distance.length; i++) {
            // 如果在s中存在该节点则继续找其他次小的节点
            if (this.s.contains(this.point[i])) {
                continue;
            } else {
                if (this.distance[i] < u) {
                    u = this.distance[i];
                    k = this.point[i];
                }
            }
        }
        return k;
    }

    // 打印结果
    private void Print() {
        for (int i = 0; i < this.distance.length; i++) {
            System.out.println(this.path[i] + ":" + this.distance[i]);
        }
    }

    public static void main(String[] args) {
        MyGraph1 graph = new MyGraph1(5, 0);
        graph.CreateMaxtrixGraph(1, 2, 2);
        graph.CreateMaxtrixGraph(1, 3, 5);
        graph.CreateMaxtrixGraph(1, 5, 3);
        graph.CreateMaxtrixGraph(2, 4, 4);
        graph.CreateMaxtrixGraph(3, 5, 5);
        graph.CreateMaxtrixGraph(4, 5, 2);
        graph.OutPutMaxtrixGraph();
        Dijkstra dijkstra = new Dijkstra(graph, 2);
        dijkstra.DijkstraCore();
    }
}

  1 2 3 4 5 
1 0 2 5 0 3 
2 2 0 0 4 0 
3 5 0 0 0 5 
4 0 4 0 0 2 
5 3 0 5 2 0 
2->1:2
2->1->3:7
2->4:4
2->1->5:5