关于使用TreeMap按照value进行排序的解决方案

今天在写Dijkstra's Algorithm用heap实现的过程中，遇到类似于使用TreeMap按照value进行排序的情况，即每个node对应一个当前最短路，将这些node按照最短路的距离排序，但是同时需要做到随时找到该点并作必要的操作。由于TreeMap是按键值排序并且不能有重复，所以产生了问题，以下提出两个解决办法：

1. 使用TreeMap按照value进行排序

具体的实现过程可以参看该链接：/liuxiao723846/article/details/50454622

         2. 使用优先队列，新建一个私有类存储node和distance，然后按照distance进行排序。

如何实现直接找到某个node对应的私有类呢？这里我们再建立一个数组记录每一个私有类对象的位置，这样就可以随时对某个node的distance做出修改。具体代码如下：

import ;
import ;
import ;
import ;
import ;
import ;
import ;

public class Week2_2 {
    
    private ArrayList<ArrayList<edge>> adjList;
//    private TreeMap<Integer,Integer> heap;
    private PriorityQueue<nodeDistance> queue;
    private nodeDistance[] recordNode;
//    private int[] minDistance;
    private int n;
    private boolean[] x;


    private class edge{
        private int pointTo;
        private int distance;
    }
    
    private class nodeDistance implements Comparable<nodeDistance>{
        int node;
        int distance;
        
        public int compareTo(nodeDistance that){
            if(<)return -1;
            if(>)return 1;
            return 0;
        }
    }
    
    public Week2_2(int n) {
        =n;
//        minDistance=new int[n];
//        minDistance[0]=0;
        recordNode=new nodeDistance[n];
        x=new boolean[n];
        queue= new PriorityQueue<nodeDistance>();
        adjList=new ArrayList<ArrayList<edge>>();
    }
    
    public void readData(String filename) throws IOException{
        

        Scanner in=new Scanner((filename));
        
        for(int i=0;i<n;i++){
            String temp=();
            String[] list=("\\s+");
//            (list[-1]);
            ArrayList<edge> adj=new ArrayList<edge>();
            
            for(int j=1;j<;j++){
                edge tempEdge=new edge();
                int index=list[j].indexOf(",", 0);
                =(list[j].substring(0, index))-1;
                =(list[j].substring(index+1, list[j].length()));
                (tempEdge);
            }
            
            (adj);
        }
    }
    
    
    
    public void dijkstraSP(){
        //initialize
        for(int i=0;i<n;i++){
            nodeDistance dis=new nodeDistance();
            =i;
            =1000000;
            recordNode[i]=dis;
            (dis);
        }      
        recordNode[0].distance=0;
        
        
        //start the algorithm
        while(!()){
            
            nodeDistance nodedistance=();
            int node=;
            x[node]=true;
            
            ArrayList<edge> adjNode=(node);
            
            for(int i=0;i<();i++){
                int pointToNode=(i).pointTo;
                if(!x[pointToNode]){
                    (recordNode[pointToNode]);
                    recordNode[pointToNode].distance=(recordNode[pointToNode].distance, +(i).distance);
                    (recordNode[pointToNode]);
                }
            }
            
            
        }
    }
    
    public void OutPut(){
        int[] set={7,37,59,82,99,115,133,165,188,197};
        HashSet<Integer> requireSet=new HashSet<Integer>();
        for(int i=0;i<;i++){
            (set[i]-1);
        }
        for(int i=0;i<n;i++){
            if((i)){
//                ("Node "+i+"'s distance= "+recordNode[i].distance);
                (recordNode[i].distance+",");
            }
        }
    }
    
    public static void main(String[] args) throws IOException {
        Week2_2 test=new Week2_2(200);
        ("./data/");
//        ("./data/");
        ();

        ();
    }
}