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

我正在尝试使用一个比较器根据列表1对列表2进行排序

因此，这两份清单是：

ListA = [2,3,4]
ListB = [8,2,4]

我需要根据列表1对列表2进行排序

预期产出：

List1: [2,3,4]
List2: [2,8,4]

这是我正在尝试的代码

Collections.sort(list1);
Collections.sort(list2,new Comparator<Integer>(){
    public int compare(Integer left,Integer right){
        return Integer.compare(list1.indexOf(left),list1.indexOf(right));
    }
})

Collections.sort（列表1）；
Collections.sort（list2，newcomparator（）{
公共整数比较（左整数、右整数）{
返回Integer.compare（list1.indexOf（左），list1.indexOf（右））；
}
})

---

这里的排序将基于List1元素的索引。上面的比较器不适用于我，请帮助？

从您的示例中，我不太清楚您想做什么，因此这个答案可能无法解决您的问题。如果您试图将ListA的排序顺序同时应用于ListA和ListB，那么您可以按如下方式执行

创建一个辅助类，允许您将两个列表与同一索引配对：

私有类IntPair实现可比较{
int i1；
int i2；
公共IntPair（inti1，inti2）{
这1.i1=i1；
这1.i2=i2；
}
公共整数比较（整数对其他）{
返回整数.compare（i1，其他.i1）；
}
}

然后从原始列表中创建一个新的

IntPair

实例列表，并对其进行排序

int size=list1.size（）；
列表aux=新阵列列表（大小）；
对于（int i=0；i

最后，将结果对列表的值复制回原始列表

for（int i=0；i

---

请注意，就算法复杂性而言，这种方法仍然是

O（nlogn）

从您的示例中，我并不完全清楚您试图做什么，因此这个答案可能无法真正解决您的问题。如果您试图将ListA的排序顺序同时应用于ListA和ListB，那么您可以按如下方式执行

创建一个辅助类，允许您将两个列表与同一索引配对：

私有类IntPair实现可比较{
int i1；
int i2；
公共IntPair（inti1，inti2）{
这1.i1=i1；
这1.i2=i2；
}
公共整数比较（整数对其他）{
返回整数.compare（i1，其他.i1）；
}
}

然后从原始列表中创建一个新的

IntPair

实例列表，并对其进行排序

int size=list1.size（）；
列表aux=新阵列列表（大小）；
对于（int i=0；i

最后，将结果对列表的值复制回原始列表

for（int i=0；i

---

请注意，就算法复杂性而言，这种方法仍然是

O（nlogn）

这可能有点重，但它完成了任务，而且是通用的

基本上，您可以压缩两个列表，根据索引对它们进行排序/比较，解压缩它们，然后返回结果

这不会修改现有的列表。我试图给变量起一个有意义但谨慎的名字。请确认我的澄清

import java.util.*;

public class SortUtil {
    public static void main(String[] args) {
        List<Integer> indicies = Arrays.asList(3, 2, 4);
        List<Integer> values   = Arrays.asList(8, 2, 4);
        List<Integer> sorted   = doSort(indicies, values, new TupleComparator<Integer>(0, 1) {
            @Override
            public int doCompare(Integer valueA, Integer valueB) {
                return Integer.compare(valueA, valueB);
            }
        });

        System.out.println(sorted); // [2, 8, 4]
    }

    public static List<Integer> doSort(List<Integer> listA, List<Integer> listB, TupleComparator<Integer> comparator) {
        List<Tuple<Integer>> tuples = zip(listA, listB);
        Collections.sort(tuples, comparator);
        return unzip(tuples, comparator.getValuePos());
    }

    private static <E> List<E> unzip(List<Tuple<E>> tuples, int index) {
        List<E> list = new ArrayList<E>();
        for (Tuple<E> tuple : tuples) {
            list.add(tuple.getData().get(index));
        }
        return list;
    }

    private static <E> List<Tuple<E>> zip(List<E> listA, List<E> listB) {
        List<Tuple<E>> listC = new ArrayList<Tuple<E>>();
        for (int i = 0; i < listA.size(); i++) {
            listC.add(new Tuple<E>(Arrays.asList(listA.get(i), listB.get(i))));
        }
        return listC;
    }

    private static abstract class TupleComparator<E> implements Comparator<Tuple<E>> {
        private int indexPos;
        private int valuePos;
        public TupleComparator(int indexPos, int valuePos) {
            this.indexPos = indexPos;
            this.valuePos = valuePos;
        }
        public int compare(Tuple<E> left, Tuple<E> right) {
            E indexA = left.getData().get(this.getIndexPos());
            E indexB = right.getData().get(this.getIndexPos());
            return doCompare(indexA,  indexB);
        }
        public int getIndexPos() { return indexPos; }
        public int getValuePos() { return valuePos; }
        public abstract int doCompare(E valueA, E valueB);
    }

    private static class Tuple<T> {
        private List<T> data;
        public Tuple(List<T> data) { this.data = data; }
        public List<T> getData() {return data; }
    }
}

import java.util.*；
公营索图提尔酒店{
公共静态void main（字符串[]args）{
列表标记=数组.asList（3,2,4）；
列表值=数组.asList（8,2,4）；
列表排序=doSort（标记、值、新元组比较符（0、1）{
@凌驾
public int doCompare（整数值A、整数值B）{
返回整数。比较（valueA、valueB）；
}
});
System.out.println（已排序）；//[2,8,4]
}
公共静态列表doSort（列表listA、列表listB、元组比较程序comparator comparator）{
列表元组=zip（listA，listB）；
集合。排序（元组、比较器）；
返回解压（元组，comparator.getValuePos（））；
}
私有静态列表解压（列表元组，int索引）{
列表=新的ArrayList（）；
for（元组：元组）{
add（tuple.getData（）.get（index））；
}
退货清单；
}
私有静态列表zip（列表listA、列表listB）{
List listC=new ArrayList（）；
对于（int i=0；i

这可能有点重，但它完成了任务，而且是通用的

基本上，您可以压缩两个列表，根据索引对它们进行排序/比较，解压缩它们，然后返回结果

这不会修改现有的列表。我试图给变量起一个有意义但谨慎的名字。请确认我的澄清

import java.util.*;

public class SortUtil {
    public static void main(String[] args) {
        List<Integer> indicies = Arrays.asList(3, 2, 4);
        List<Integer> values   = Arrays.asList(8, 2, 4);
        List<Integer> sorted   = doSort(indicies, values, new TupleComparator<Integer>(0, 1) {
            @Override
            public int doCompare(Integer valueA, Integer valueB) {
                return Integer.compare(valueA, valueB);
            }
        });

        System.out.println(sorted); // [2, 8, 4]
    }

    public static List<Integer> doSort(List<Integer> listA, List<Integer> listB, TupleComparator<Integer> comparator) {
        List<Tuple<Integer>> tuples = zip(listA, listB);
        Collections.sort(tuples, comparator);
        return unzip(tuples, comparator.getValuePos());
    }

    private static <E> List<E> unzip(List<Tuple<E>> tuples, int index) {
        List<E> list = new ArrayList<E>();
        for (Tuple<E> tuple : tuples) {
            list.add(tuple.getData().get(index));
        }
        return list;
    }

    private static <E> List<Tuple<E>> zip(List<E> listA, List<E> listB) {
        List<Tuple<E>> listC = new ArrayList<Tuple<E>>();
        for (int i = 0; i < listA.size(); i++) {
            listC.add(new Tuple<E>(Arrays.asList(listA.get(i), listB.get(i))));
        }
        return listC;
    }

    private static abstract class TupleComparator<E> implements Comparator<Tuple<E>> {
        private int indexPos;
        private int valuePos;
        public TupleComparator(int indexPos, int valuePos) {
            this.indexPos = indexPos;
            this.valuePos = valuePos;
        }
        public int compare(Tuple<E> left, Tuple<E> right) {
            E indexA = left.getData().get(this.getIndexPos());
            E indexB = right.getData().get(this.getIndexPos());
            return doCompare(indexA,  indexB);
        }
        public int getIndexPos() { return indexPos; }
        public int getValuePos() { return valuePos; }
        public abstract int doCompare(E valueA, E valueB);
    }

    private static class Tuple<T> {
        private List<T> data;
        public Tuple(List<T> data) { this.data = data; }
        public List<T> getData() {return data; }
    }
}

import java.util.*；
公营索图提尔酒店{
公共静态void main（字符串[]args）{
列表标记=数组.asList（3,2,4）；
列表值=Arr