如何在java中对数组排序并跟踪索引

我试图对整数数组进行排序（递减），但要跟踪原始索引

我的意思是，例如，如果我有这个数组：

b[] = { 4, 5, 3, 5, 2 }   

使用Arrays.sort（b，Collections.reverseOrder（））后，它会变成 （我使用Arrays.sort，因为在本例中，b的长度仅为5，但在我的问题中，b的长度可能为1

b[] = { 5, 5, 4, 3, 2 }

但我想以某种方式得到原始索引，我的意思是知道这一点

bOrignalIndex[] = { 1, 3, 0, 2, 4 }

我不知道我的问题是否清楚，请问我所有的问题。 我有C++中的这段代码，因为它能做到我想要的< /P>

n=4
m=5
tord[] =  
[0] 0   
[1] 1   
[2] 2   
[3] 3   
ts[] =      
[0] 4   
[1] 5   
[2] 3   
[3] 5   



   tord[MAXT], ts[MAXT];
       bool ord(int a, int b){
        return ts[a] > ts[b];    }
    int main(void){
        for(int m, n; scanf("%d %d", &m, &n)){
            bool possible = true;
            FOR(i=0;i<m, i++){ // for each team
                scanf("%d", ts + i); // read team size
                tord[i] = i;
            }
            sort(tord, tord + m, ord)

---

尝试按值对

（值、索引）

进行排序：

public class Pair implements Comparable<Pair> {
    public final int index;
    public final int value;

    public Pair(int index, int value) {
        this.index = index;
        this.value = value;
    }

    @Override
    public int compareTo(Pair other) {
        //multiplied to -1 as the author need descending sort order
        return -1 * Integer.valueOf(this.value).compareTo(other.value);
    }
}

现在，您有了一个按降序排列的

对

对象数组。每个对象还包含

索引

——原始数组中的位置

---

另外，我用Java编写了这个示例，因为问题有

Java

标记。虽然在

C++

中想法是一样的，只是实现有一点不同。

OP poster的示例涉及到对整数数组进行排序。如果任何读者有类似的情况，但使用非原语类型的数组，则Owning是一个处理非原语数组的类。该类采用一种稍微不同的方法。它不修改原始数组，而是创建一个索引数组、排序数组并返回该数组

public class IndirectSorter<T extends Comparable<T>> {
    public int[] sort(T args[]) {
        Integer origindex[] = new Integer[args.length];
        int retval[] = new int[args.length];
        for (int i=0; i<origindex.length; i++) {
            origindex[i] = new Integer(i);
        }
        Arrays.sort(origindex, new IndirectCompareClass<T>(args));
        for (int i=0; i<origindex.length; i++) retval[i] = origindex[i].intValue();
        return retval;
    }

    class IndirectCompareClass<T extends Comparable<T>> implements Comparator<Integer> {
        T args[];
        public IndirectCompareClass(T args[]) { this.args = args; }
        public int compare( Integer in1, Integer in2 ) {
            return args[in1.intValue()].compareTo(args[in2.intValue()]);
        }
        public boolean equals( Integer in1, Integer in2 ) {
            return args[in1.intValue()].equals(args[in2.intValue()]);
        }
    }
}

公共类间接分拣机{
公共int[]排序（T参数[]）{
整数origindex[]=新整数[args.length]；
int retval[]=new int[args.length]；
对于（int i=0；i，以下答案提供了克服问题中所述问题的主要步骤，但未提供详细代码


您可以创建自定义的
类
，该类有两个属性
值
和
索引
。其中
值
是原始属性值，
索引
是排序前的位置
创建此
类的
ArrayList

使用所需的
值和
索引添加所创建的
类的新对象


注意：设置
索引
值的一种可能方法是迭代
数组列表
并使用循环索引设置
索引
的值


基于
value
属性，使用特殊的
compariable
对
Arraylist
进行排序


现在，在排序之后，您可以通过调用任何条目的
索引
属性来了解其前面的
索引
。
听起来像。还有很多类似的，非常感谢您的回答：）.我只是在Pair类中实现了另外两个方法，用于返回值和索引，有没有java8更简单的方法？我需要对int数组进行排序，但如果值与索引较低的数组相同，则首先进行排序。是的，我需要跟踪原始索引。映射呢？我想这是一种更简单的方法，使用map。
public static void main(String[] args) {
    Pair[] yourArray = new Pair[10];

    //fill the array
    yourArray[0] = new Pair(0, 5); yourArray[1] = new Pair(1, 10); //and so on
    Arrays.sort(yourArray);
}

public class IndirectSorter<T extends Comparable<T>> {
    public int[] sort(T args[]) {
        Integer origindex[] = new Integer[args.length];
        int retval[] = new int[args.length];
        for (int i=0; i<origindex.length; i++) {
            origindex[i] = new Integer(i);
        }
        Arrays.sort(origindex, new IndirectCompareClass<T>(args));
        for (int i=0; i<origindex.length; i++) retval[i] = origindex[i].intValue();
        return retval;
    }

    class IndirectCompareClass<T extends Comparable<T>> implements Comparator<Integer> {
        T args[];
        public IndirectCompareClass(T args[]) { this.args = args; }
        public int compare( Integer in1, Integer in2 ) {
            return args[in1.intValue()].compareTo(args[in2.intValue()]);
        }
        public boolean equals( Integer in1, Integer in2 ) {
            return args[in1.intValue()].equals(args[in2.intValue()]);
        }
    }
}

public static void main(String args[] ) {
    int indexes[] = new IndirectSorter<String>().sort(args);
    for (int i : indexes) {
        System.out.printf("original pos: %d %s\n", i, args[i] );
    }
}