对整数进行排序，但保留索引以恢复其顺序

Question

我希望您能够提出一种方法，在该方法中，我想对一组整数值进行排序，但保留其索引记忆。

这就是我想对整数进行排序，对它们执行一些操作，然后在排序之前将它们恢复到相同顺序。

对数据结构或算法有何建议？

Answer 1

您需要将数据及其原始索引放入一个类中，并以仅比较数据的方式定义比较。

public class SortItemHelper implements Comparable<SortItemHelper> 
{ 
    Data data; 
    int originalIndex; 

    public int compareTo(SortItemHelper other) 
    { 
     if (other == null) 
      return 1; 
     return data.compareTo(other.data); 
    } 
    ... 
} 

（你想使这个在Data通用。）

Answer 2

使它所以要排序的对象数组（可能是包装类自己设计），它知道它自己的位置）。

Answer 3

如果有人正在寻找一个通用的实现，我已经做了一个。

基本抽象类：

public abstract class AbstractSortHelper<T> implements Comparable<AbstractSortHelper<T>> { 
    protected final int index; 
    protected final T data; 

    public AbstractSortHelper(int index, T data) { 
     this.index = index; 
     this.data = data; 
    } 

    public int getIndex() { 
     return index; 
    } 

    public T getData() { 
     return data; 
    } 
} 

第一延伸类可用于实现比较的对象：

public class ComparableSortHelper<T extends Comparable> extends AbstractSortHelper<T> { 

    public ComparableSortHelper(int index, T data) { 
     super(index, data); 
    } 

    @Override 
    public int compareTo(AbstractSortHelper<T> o) { 
     return this.data.compareTo(o.data); 
    } 
} 

第二伸出类可用于不执行比较的对象。当使用您必须实现一个比较：

public abstract class ComparatorSortHelper<T> extends AbstractSortHelper<T> implements Comparator<T> { 

    public ComparatorSortHelper(int index, T data) { 
     super(index, data); 
    } 

    @Override 
    public int compareTo(AbstractSortHelper<T> { 
     return compare(this.data, o.data); 
    } 
} 

扩展ComparatorSortHelper看起来是这样的：

class DataSortHelper extends ComparatorSortHelper<Object[]> { 

    public DataSortHelper(int index, Object[] data) { 
     super(index, data); 
    } 

    @Override 
    public int compare(Object[] o1, Object[] o2) { 
     return Integer.compare((Integer) o1[0], (Integer) o2[0]); 
    } 
} 

使用此之后，排序很简单：

List<DataSortHelper> list = new ArrayList<>(); 
// ... 
Collections.sort(list); 

希望它可以帮助别人。 :)