根据另一个列表对列表进行排序'；s值-Java

一张名单上有名字：（未排序）例如[保罗，犯规，马克]

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

第二个列表上的值是每个人（姓名）选择的数字，因此 保罗的号码是5，犯规的号码是2，马克的号码是6

---

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

使用排序方法，我得到了这样的列表：[保罗，马克，犯规]

正如你所看到的，它没有按照我想要的排序

正确的应该是：[马克，保罗，犯规]

但是我找不到密码上的错误

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;

}

公共ArrayList排序名称（ArrayList结果）{
串tmp；
对于（int k=0；k您正在根据列表结果的值对列表名称进行排序…它只会因为条件
k而终止
通过成对地从两个列表中获取元素（具有将两个值存储为字段的类），构建一个成对（名称、值）的列表。实现Compariable以比较值字段

使用集合对结果进行排序。排序（）

从排序列表中提取名称

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

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); }
});

Map m=新的HashMap；
对于（int i=0；i

即使某些数字相等，这个解决方案也会起作用。
你会得到最简单的快速排序，最简单的原则是：交换第一个列表时，交换第二个列表。希望这不是家庭作业，但即使不是。。。
简而言之，复制/粘贴并享受
快速排序（列表1，列表2）
是您所需要的一切。列表按第一个列表进行排序，或者按
可比的定义排序

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());
}

私有静态无效交换（列表l1、列表l2、int i、int j）{
集合交换（l1、i、j）；
集合交换（l2，i，j）；
}
私有静态去掉这两个列表。如果数据是相关的，那么数据应该一起存储在一个简单的类中。然后整个类被添加到一个列表中，如果需要，您可以在其中对单个属性进行排序。您可以使用一个来按自己的意愿对该列表进行排序。
关于交换，您说的是wright！谢谢！您能解释一下吗一开始你说的是什么意思？我知道bubblesort不需要大小计数器上的-1。但是只测试你发布的第二个便笺，我就得到了正确的结果。第一个便笺对它没有什么反应？：/EDIT：在编辑之前发布的注释。通常情况下，气泡排序会因为外部循环中断而终止。这是错误的众所周知，它不需要超过N-1次迭代，但您不需要这样的条件。错误的实现永远不会终止（除非从排序序列开始）。但这并不重要……这只是我看到的第一个想法。
Collections.sort（）
需要一个
列表
，而
HashMap
无法实现。
使用map后，可以单独使用这两个列表吗？
-当然，map只是临时的。
至于bubblesort
-以防列表很短（
Collections.sort（））需要一个HashMap无法实现的列表。
-我使用
排序（map）
是不是一个傻瓜？“我不能使用map，因为我在我的程序的其他场合需要这两个列表。”确切地说，要做什么？其他类上需要列表。例如，是否可以在地图上对它们进行排序，然后分别使用它们？：/write您在网上找到的任何排序算法quick/merge/shell/whatever，当您交换时，将这两个列表交换给提供地图使用的任何人：它不允许重复我知道它不能，但可能是多重地图（例如来自番石榴）谢谢Karl Knechtel。你的建议是对的。我仍然在想，如果不使用另一个类，最好让它像我发布的那样，只使用@maaartinus所说的排序第二个列表。正如你所看到的，使用自制算法很容易出错。而buublesort对于较长的列表来说简直太糟糕了。顺便说一句，我在第一次编辑结束时提到了卡尔的方法，写得太多了。啊哈，谢谢maaartinus。至于bubblesort，请记住我的列表的最大大小为4。所以我认为气泡效应不会太大，这就是我选择它的原因。谢谢你的想法。@maaartinus如果你不能实现排序算法，那就没有什么意义了测试这个。我在第行得到一个错误：“Names.sort（new Comparator（）{”oops。如果我能很好地理解这一行，你可以对名称进行排序，对吗？但是它用数字单独排序，而不是根据它们的值。不？@FILIas我忘记了排序（）方法不在列表中，现在应该可以使用了。比较器使用前面的映射进行排序，降序也在这里。对，miah。但是不同的值呢。你确定它对相同的值也有效吗？因为通常hashmaps不起作用。该映射是Name->Number，而不是其他方式。名称是唯一的，对吗？^这应该是accepted答案，即使它不能直接回答问题。我本来打算将int+字符串包装到一个可比较的类中并对其进行排序，然后将其展开，但这只是因为数据结构有缺陷。在java中使用2/3/n独立数组是一种很好的做法（但在c中不是这样）。它的工作原理非常简单，但像复数这样的结构非常多；与类复数{double a，b}的数组相比，使用两个数组double[]a，b}在性能（和内存）方面要好得多。然而，仅在这种情况下。这不起作用。例如，try
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());

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); }
});

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());
}