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

第一个可用于实现Comparable的对象的扩展类：

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

第二个扩展类，可用于未实现Comparable的对象。使用时必须实现比较器：

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

希望它有所帮助。：）

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

3 个答案: