根据另一个列表的值对列表进行排序 - Java

Question

一个带有名字的列表：（未排序）例如[paul，follow，mark]

另一个整数列表：例如 [5, 2, 6]

第二个列表中的值是每个人（姓名）“选择”的数字，所以 保罗5号，犯规2号，马克6号。

我正在尝试根据第二个列表的值按降序对姓名列表进行排序。我不能使用地图，因为我在程序的其他场合需要这两个列表。

使用排序方法我做了我得到这样的列表：[paul, mark, fur]

如您所见，它没有按我想要的方式排序。

正确的应该是：[mark,paul,foul]

但我找不到代码的错误。

public ArrayList<String> sortNames(ArrayList<Integer> results){
    String tmp;
    for (int k=0; k<Names.size()-1; k++) {

        boolean isSorted=true;
        for (int i=1; i<Names.size()-k; i++) {

             if (results.get(i)>results.get(i-1)  ) {

                tmp=Names.get(i);
                Names.set(i,Names.get(i-1));
                Names.set(i-1,tmp);

                isSorted=false;
            }
        }
        if (isSorted) break;
    }
    return Names;

}

编辑！！！在下面的答案的帮助下，代码是：

    public ArrayList<String> sortNames(ArrayList<Integer> results){
        String tmp2;
        int tmp;
        for (int k=0; k<Names.size()-1; k++) {

            boolean isSorted=true;
            for (int i=1; i<Names.size()-k; i++) {

                 if (results.get(i)>results.get(i-1)  ) {
                     tmp=results.get(i);
                     results.set(i,results.get(i-1));
                     results.set(i-1,tmp);


                    tmp2=Names.get(i);
                    Names.set(i,Names.get(i-1));
                    Names.set(i-1,tmp2);

                    isSorted=false;
                }
            }
            if (isSorted) break;
        }
    return Names;

}

此代码正常工作（对于小列表） 我只是询问为什么它不适用于 ImageIcon 之类的对象。有什么想法吗？

Answer 1

摆脱这两个列表。如果数据是相关的，那么数据应该一起存储在一个简单的类中。然后将整个类添加到列表中，如果需要，您可以在其中对各个属性进行排序。您可以使用Bean Comparator 对这个列表进行任何您想要的排序。

Answer 2

您正在根据列表结果的值对列表名称进行排序......并且它仅由于条件k<Names.size()-1 而终止。这样的条件在冒泡排序中通常是不需要的，这就说明有问题了。

您必须交换两个列表中的元素，而不仅仅是名称。这就是答案，但请注意冒泡排序是有史以来最糟糕的算法之一。

编辑：

我不能使用地图，因为我在程序的其他场合需要这两个列表。

当然可以（假设数字是唯一的）：

Map<Integer, String> m = new HashMap<Integer, String>();
for (int i=0; i<results.size(); ++i) m.put(results.get(i), Names.get(i));
Collections.sort(results);
for (int i=0; i<results.size(); ++i) Names.set(i, m.get(results.get(i));

可能有错误，但思路要清楚。

还有另一种解决方案，使用一类对（结果、名称），如果您需要，它甚至可以处理非唯一数字。

稍微短一点的解决方案：

Map<Integer, String> m = new TreeMap<Integer, String>();
for (int i=0; i<results.size(); ++i) m.put(results.get(i), Names.get(i));
Names.clear();
Names.addAll(m.values());

这是基于TreeSet.values“集合的迭代器按相应键的升序返回值”和List.addAll“附加指定的所有元素的属性集合到此列表的末尾，按照指定集合的​​迭代器返回的顺序"

Answer 3

1. 通过成对地从两个列表中获取元素（具有将两个值存储为字段的类）来构建（名称，值）对的列表。实现 Comparable 来比较 value 字段。

2. 使用Collections.sort()对结果进行排序。

3. 从排序列表中提取名称。

Answer 4

你可以使用你所得到的最普通的快速排序，最简单的原则是：当你交换第一个列表时，你去交换第二个。希望这不是家庭作业，但即使不是…… 简而言之，复制/粘贴并享受quickSort(list1, list2) 就是您所需要的。列表按Comparable 定义的第一个列表自然顺序排序。

private static void swap(List<?> l1, List<?> l2, int i, int j){
    Collections.swap(l1, i, j);
    Collections.swap(l2, i, j);     
}
private static <T extends Comparable<? super T>>  int partition(List<T> comp, List<?> l2, int left, int right){
    int i = left, j = right;
    T pivot = comp.get((left + right) / 2);

    while (i <= j) {
        while (comp.get(i).compareTo(pivot)<0)
            i++;

        while (comp.get(i).compareTo(pivot)>0)
            j--;

        if (i <= j) {
            swap(comp, l2, i++, j--);
        }
    };
    return i;
}
private <T extends Comparable<? super T>>  void quickSort(List<T> comp, List<?> l2, int left, int right) {
    int index = partition(comp, l2, left, right);

    if (left < index - 1)
        quickSort(comp, l2, left, index - 1);

    if (index < right)
        quickSort(comp, l2, index, right);
}

public <T extends Comparable<? super T>>  void quickSort(List<T> comp, List<?> l2) {
    if (comp.size()<l2.size())
        throw new IndexOutOfBoundsException();
    quickSort(comp, l2, 0, comp.size());
}

Answer 5

创建一个临时映射名称->编号，然后使用使用该映射的自定义比较器对名称进行排序：

Map<String, Integer> m = new HashMap<String, Integer>;
for(int i = 0; i < Names.size(); i++)
    m.put(Names.get(i), results.get(i));
Collections.sort(Names, new Comparator<String>() {
    @Override
    public int compare(String s1, s2) { return m.get(s2) - m.get(s1); }
});

即使某些数字相等，此解决方案也有效。