java-根据指定的整数值对字符串的链表进行排序

我有一个字符串的链表，每个字符串都有一个计算所得的整数值。为了便于解释，我有一个表示节点的字符串链表。每个节点都有一个距离。要获得距离，可以使用我在程序中创建的方法返回该节点的距离。我希望链表按字符串的每个距离排序，从最低到最高。我该怎么做？这是一个密码

Queue<String> someStringList = new LinkedList<String>();

Queue someStringList=new LinkedList（）；

列表中每个节点的

字符串节点=（（LinkedList）someStringList.get（i）；
距离=节点距离（节点）；
按节点的距离对链表排序
...
公共整数距离（字符串str）{
返回距离；

---

}第一个选项是创建一个比较器，然后对集合进行排序。我会这样做：

  public static void main(String... arg) {
        LinkedList<String> someStringList = new LinkedList<>();

        someStringList.add("2");
        someStringList.add("1");

        System.out.println(someStringList);

        Collections.sort(someStringList, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return theNodesDistance(s1).compareTo(theNodesDistance(s2));
            }

        });
        System.out.println(someStringList);

    }
    public static Integer theNodesDistance(String str){
        return Integer.parseInt(str); // here return the distance
    }

---

如果您可以在重复计算距离时浪费CPU，那么您可以使用JDK排序方法和比较器实现来计算任意2个字符串的距离并进行比较。这是最简单的

如果希望只计算一次每个字符串的距离（假定这是昂贵的），则可以：

a） 构造一个新的元组集合（字符串和距离），并按距离对元组进行排序（再次使用比较器，或者通过使元组类具有可比性）

---

b） 或者，您可以尝试将距离缓存在字符串的哈希映射中，以达到比较器所依赖的距离。

您可以使用TreeMap。。以下是一个正常的演示-

    TreeMap<Integer, String> tmap = new TreeMap<Integer, String>(); 
/*Adding elements to TreeMap*/
 tmap.put(1, "Data1"); 
tmap.put(23, "Data2"); 
tmap.put(70, "Data3"); 
tmap.put(4, "Data4"); 
tmap.put(2, "Data5"); 
/* Display content using Iterator*/ 
Set set = tmap.entrySet();
 Iterator iterator = set.iterator();
 while(iterator.hasNext()) { 
Map.Entry mentry = (Map.Entry)iterator.next();
 System.out.print("key is: "+ mentry.getKey() + " & Value is: ");
 System.out.println(mentry.getValue()); 
} 

---

您可以使用排序算法。像selectionsort，bubblesort。。。 这是insertionsort

double temp;
for(int i = 1;i<yourList.size();i++)
{
temp = thenodedistance(yourlist.get(i));
int j = i;
    while(j>0&&thenodedistance(yourlist.get(j-1))> temp)
    {
        yourlist.add(j,yourlist.remove(j-1);
        j--;
    }
    yourlist.add(j,yourliste.remove(i));
}

双温；
对于（inti=1；i0&&thenodedistance（yourlist.get（j-1））>temp）
{
yourlist.add（j，yourlist.remove）（j-1）；
j--；
}
添加（j，yourliste.remove（i））；
}

---

通过这种方式，您可以对列表进行排序（没有尝试代码…）

使用节点类怎么样

class Node{
   String str;
   int distance;
   public Node(String str){
       this.str = str;
       this.distance = theNodesDistance(str);
   }
}

然后您可以重写一个比较器。我建议您使用PriorityQueue而不是LinkedList，这样您对有序列表的插入可以更有效（O（logn））。在这种情况下，您实际上不需要调用排序或heapify函数，因为优先级队列始终保持节点的有序

Queue<Node> nodes = new PriorityQueue<>();
nodes.add(new Node("10"));
nodes.add(new Node("3"));
nodes.add(new Node("2"));
nodes.add(new Node("1"));
nodes.add(new Node("4"));

System.out.println(nodes.remove());
System.out.println(nodes.remove());
System.out.println(nodes.remove());
System.out.println(nodes.remove());
System.out.println(nodes.remove());

PriorityQueue que = new PriorityQueue(new Comparator<Node>(){
     public int compare(Node n1, Node n2){
          if(n1.distance < n2. distance) return -1;
          else if(n1.distance > n2.distance) return 1;
          return 0;
     }
});

---

您需要一个节点类来表示封装了距离的节点&实现基于距离的可比比较节点您可以简单地执行类似于

Comparator.comparingit（Someclass:：theNodesDistance）的操作

，无需实现

比较器

。对于第二组代码，我是否将其添加到节点类或其他类？我认为最好添加到另一个类。是否有理由不使用

集合。排序

？

    TreeMap<Integer, String> tmap = new TreeMap<Integer, String>(); 
/*Adding elements to TreeMap*/
 tmap.put(1, "Data1"); 
tmap.put(23, "Data2"); 
tmap.put(70, "Data3"); 
tmap.put(4, "Data4"); 
tmap.put(2, "Data5"); 
/* Display content using Iterator*/ 
Set set = tmap.entrySet();
 Iterator iterator = set.iterator();
 while(iterator.hasNext()) { 
Map.Entry mentry = (Map.Entry)iterator.next();
 System.out.print("key is: "+ mentry.getKey() + " & Value is: ");
 System.out.println(mentry.getValue()); 
} 

key is: 1 & Value is: Data1 
key is: 2 & Value is: Data5 
key is: 4 & Value is: Data4 
key is: 23 & Value is: Data2 
key is: 70 & Value is: Data3

double temp;
for(int i = 1;i<yourList.size();i++)
{
temp = thenodedistance(yourlist.get(i));
int j = i;
    while(j>0&&thenodedistance(yourlist.get(j-1))> temp)
    {
        yourlist.add(j,yourlist.remove(j-1);
        j--;
    }
    yourlist.add(j,yourliste.remove(i));
}

class Node{
   String str;
   int distance;
   public Node(String str){
       this.str = str;
       this.distance = theNodesDistance(str);
   }
}

PriorityQueue que = new PriorityQueue(new Comparator<Node>(){
     public int compare(Node n1, Node n2){
          if(n1.distance < n2. distance) return -1;
          else if(n1.distance > n2.distance) return 1;
          return 0;
     }
});

for(each str){
    que.add(new Node(str));
}