简单Dijkstra算法

Dijkstra算法是单源最短路径算法，它通过贪心法求得某一点在相邻区域的最优解，所以它不能处理存在负边的图。Dijkstra算法会遍历很大范围的节点，从而得出短路径的最优解。

算法思想

设G = ( V, E )是简单图（不含有自环） ，V是图中的顶点集合，E是边集合。V集合中每个顶点带权（从源点到该点的路径总长），未明确权或未设置权的顶点放在集合U，已设置权且不再改变权的顶点放在集合S。当顶点从U移动到S的过程中，顶点权值小于所有相邻节点的权值。当终点的权确定后，即找到从源点到终点的最短路径。

算法过程

1、从起点开始，访问所有与起点邻接且未确定长度的点
2、设置邻接点最小路径长度，此时起点路径长度已确定
3、从所有未确定长度的点中找出路径长度最小的点，设置改点为起点
4、重复1过程，直至找到终点或点集合为空

邻接矩阵

现有无向图如下，求从A到E的最短路径

求得相邻矩阵matrix如下

		0	1	2	3	4	5	6	7
		A	B	C	D	E	F	G	H
0	A	0	5	3
1	B	5	0		2	2
2	C	3		0	4		3		6
3	D		2	4	0	2		5
4	E		2		2	0		5
5	F			3			0		4
6	G				5	5		0
7	H			6			4		0

完整代码

设置权的结构，包含路径节点和路径长度

import java.util.*;

public class Main {

    static class NodeWeight implements Comparable<NodeWeight> {
        Integer node;
        Integer length;
        List<Integer> pathList = new LinkedList<>();

        @Override
        public int compareTo(NodeWeight node) {
            return this.length.compareTo(node.length);
        }
    }

    public static void main(String[] args) {
        Integer[][] matrix = new Integer[8][8];
        matrix[1][0] = 5;
        matrix[2][0] = 3;
        matrix[3][1] = 2;
        matrix[3][2] = 4;
        matrix[4][1] = 2;
        matrix[4][3] = 2;
        matrix[5][2] = 3;
        matrix[6][3] = 5;
        matrix[6][4] = 5;
        matrix[7][2] = 6;
        matrix[7][5] = 4;
        for (Integer i = 0; i < matrix.length; i++) {
            for (Integer j = 0; j < matrix[i].length; j++) {
                if (matrix[i][j] != null) {
                    matrix[j][i] = matrix[i][j];
                }
                if (i.equals(j)) {
                    matrix[i][j] = 0;
                }
            }
        }
        print(sortDijkstra(0, 0, matrix));
    }

    private static void addWeight(NodeWeight nodeWeight, List<NodeWeight> nodeWeightList) {
        ListIterator<NodeWeight> listIterator = nodeWeightList.listIterator();
        while (true) {
            //根据权重为节点排序
            //根据前后节点的长度选择合适的位置插入该节点
            Integer pre = Integer.MIN_VALUE;
            if (listIterator.hasPrevious()) {
                pre = listIterator.previous().length;
                listIterator.next();
            }
            Integer next = listIterator.hasNext() ? listIterator.next().length : Integer.MAX_VALUE;
            if (nodeWeight.length >= pre && nodeWeight.length < next) {
                listIterator.add(nodeWeight);
                break;
            }
        }
    }

    private static NodeWeight sortDijkstra(Integer startNode, Integer endNode, Integer[][] matrix) {
        //权重列表（有序），权重集合，移除节点集合
        List<NodeWeight> nodeWeightList = new LinkedList<>();
        NodeWeight[] nodeWeights = new NodeWeight[matrix.length];
        Boolean[] excludes = new Boolean[matrix.length];
        //初始化起始节点
        nodeWeights[startNode] = new NodeWeight();
        nodeWeights[startNode].node = startNode;
        nodeWeights[startNode].length = 0;
        nodeWeights[startNode].pathList = new ArrayList<>();
        nodeWeights[startNode].pathList.add(startNode);
        //设置当前节点，设置当前节点路径上的最小路径目标节点
        Integer currentNode = startNode;
        while (true) {
            for (Integer targetNode = 0; targetNode < matrix[currentNode].length; targetNode++) {
                if (!targetNode.equals(currentNode) && matrix[currentNode][targetNode] != null && excludes[targetNode] == null) {
                    //如果目的节点不等于当前节点，目的节点不为空，目的节点未被移除
                    Integer targetNodePathLength = nodeWeights[currentNode].length + matrix[currentNode][targetNode];
                    if (nodeWeights[targetNode] == null) {
                        //目的节点路径为空
                        nodeWeights[targetNode] = new NodeWeight();
                        nodeWeights[targetNode].node = targetNode;
                        nodeWeights[targetNode].length = targetNodePathLength;
                        nodeWeights[targetNode].pathList = new ArrayList<>(nodeWeights[currentNode].pathList);
                        nodeWeights[targetNode].pathList.add(targetNode);
                        addWeight(nodeWeights[targetNode], nodeWeightList);
                    } else if (nodeWeights[targetNode].length > targetNodePathLength) {
                        nodeWeights[targetNode].length = targetNodePathLength;
                        nodeWeights[targetNode].pathList = new ArrayList<>(nodeWeights[currentNode].pathList);
                        nodeWeights[targetNode].pathList.add(targetNode);
                    }
                }
            }
            //如果集合为空或者终点已经确定权值，则路径查找结束
            if (nodeWeightList.size() > 0 && !currentNode.equals(endNode)) {
                excludes[currentNode] = false;
                currentNode = nodeWeightList.get(0).node;
                nodeWeightList.remove(0);
            } else {
                return nodeWeights[endNode];
            }
        }
    }

    private static void print(NodeWeight nodeWeight) {
        Character[] charNode = new Character[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'};
        System.out.print(nodeWeight.length + "\t" + charNode[nodeWeight.node] + "\t");
        for (Integer i : nodeWeight.pathList) {
            System.out.print(charNode[i] + " - ");
        }
        System.out.println();
    }
}