迪瑞克斯拉算法

迪瑞克斯拉算法 — 优化

在上一篇迪瑞克斯拉算法中将功能实现了出来，完成了图集中从源点出发获取所有可达的点的最短距离的收集。
但在代码中getMinDistanceAndUnSelectNode()方法的实现并不简洁，每次获取minNode时，都需要遍历整个Map，时间复杂度太高。这篇文章主要是针对上一篇文章代码的一个优化。
其优化的过程中主要是用到了加强堆的数据结构，如果不了解的强烈建议先看加强堆的具体实现。

回顾：

在这里插入图片描述
上一篇中，将确定不变的点放入Set中，每个点之间的距离关系放入Map中，每次遍历Map获取最小minNode，并根据该点找到所有的边，算出最小距离后，放入set中，最终确定最小距离表。

优化
利用加强堆，来维护点和距离的关系，并利用小根堆的优势，让最小的点总是在最上面，需要注意的是，以往的的加强堆中，如果移除了这个元素会直接remove，但是在这里不能remove，因为要记录这个点是否在堆上，是否加入过堆，所以对于确定了的元素，value要改成 -1，用来标记当前元素已经确定，不用再动。

加强堆代码
NodeHeap中的distanceMap用来表示点和距离的关系，根据value的大小动态变化堆顶元素。
主方法是addOrUpdateOrIgnore()。
如果当前元素在堆中并且value != 1（inHeap），说明元素还没有确定，则判断进来的node和value是否大于当前堆中的node对应的value，取小的更新，如果更新，还需要改变元素在堆中位置，因为只可能越更新越小。所以要调用insertHeapify方法去改变堆结构。
如果元素还未加入过堆（!isEntered），则挂在堆尾，并insertHeapify检查是否上移。
pop方法中，如果弹出堆，正常要删除，但是不能删除，除了和最后一个元素交换，下移外，将distanceMap中对应的值改为 -1。否则无法判断该元素是否已经加入过堆，是否已经确定。

public static class NodeHeap {
        //Node类型的堆
        private Node[] nodes;
        //key对应的Node在堆中的位置是value
        private HashMap<Node, Integer> heapIndexMap;
        //key对应的Node当前距离源点最近距离
        private HashMap<Node, Integer> distanceMap;
        //堆大小
        private int size;

        public NodeHeap(int size) {
            nodes = new Node[size];
            heapIndexMap = new HashMap<>();
            distanceMap = new HashMap<>();
            this.size = 0;
        }

        public boolean isEmpty() {
            return this.size == 0;
        }

        public boolean isEntered(Node head) {
            return heapIndexMap.containsKey(head);
        }

        public boolean inHeap(Node head) {
            return isEntered(head) && heapIndexMap.get(head) != -1;
        }

        public void swap(int index1, int index2) {
            heapIndexMap.put(nodes[index1], index2);
            heapIndexMap.put(nodes[index2], index1);

            Node tmp = nodes[index1];
            nodes[index1] = nodes[index2];
            nodes[index2] = tmp;
        }

        public void heapify(int index, int size) {
            int left = (index * 2) - 1;
            while (left < size) {
                int smallest = left + 1 < size && distanceMap.get(nodes[left + 1]) < distanceMap.get(nodes[left]) ? left + 1 : left;
                smallest = distanceMap.get(nodes[smallest]) < distanceMap.get(nodes[index]) ? smallest : index;

                if (smallest == index) {
                    break;
                }
                swap(smallest, index);
                index = smallest;
                left = (index * 2) - 1;
            }
        }

        public void insertHeapify(Node node, int index) {
            while (distanceMap.get(nodes[index]) < distanceMap.get((index - 1) / 2)) {
                swap(distanceMap.get(nodes[index]), distanceMap.get((index - 1) / 2));
                index = (index - 1) / 2;
            }
        }

        public NodeRecord pop() {
            NodeRecord nodeRecord = new NodeRecord(nodes[0], distanceMap.get(0));
            swap(0, size - 1);
            heapIndexMap.put(nodes[size - 1], -1);
            distanceMap.remove(nodes[size - 1]);
            heapify(0, --size);
            return nodeRecord;
        }

        public void addOrUpdateOrIgnore(Node node, int distance) {
            if (inHeap(node)) {
                distanceMap.put(node, Math.min(distanceMap.get(node), distance));
                insertHeapify(node, distanceMap.get(node));
            }
            if (!isEntered(node)) {
                nodes[size] = node;
                heapIndexMap.put(node, size);
                distanceMap.put(node, distance);
                insertHeapify(node, size++);
            }
        }
    }

主方法逻辑
上来将给定的点添加到堆中，并且弹出，遍历所有的边放到加强堆中去搞。

  public static HashMap<Node, Integer> dijkstra2(Node head, int size) {
        NodeHeap nh = new NodeHeap(size);
        nh.addOrUpdateOrIgnore(head, 0);
        HashMap<Node, Integer> result = new HashMap<>();

        while (!nh.isEmpty()) {
            NodeRecord record = nh.pop();
            Node cur = record.node;
            int distance = record.distance;

            for (Edge edge : cur.edges) {
                nh.addOrUpdateOrIgnore(edge.to, distance + edge.weight);
            }
            result.put(cur, distance);
        }
        return result;
    }