Java - 对数组进行排序[关闭]答案

【问题标题】：Java - Sorting an array [closed]Java - 对数组进行排序[关闭]
【发布时间】：2014-09-11 01:27:08
【问题描述】：

我需要帮助..

我有一个包含浮点数的数组列表：

[.43423, .2132, .3242, .....]

我想创建一个新数组，对该列表进行排序并生成类似

[1, 3, 2, ....]

.43423 becomes 1 because it is the biggest
.3242 becomes 2 because it is the next biggest
etc..

如果小数点相同，则它们成为相同的整数值。

我该怎么做呢？感谢您的帮助

【问题讨论】：

为什么是[1, 3, 2]？为什么不[1, 2, 3]？
@BitNinja 我认为这是一个错字
不，这不是错字。这是因为这就是我必须这样做的方式。目前我的代码非常草率。
@Sameer，我想出了一个解决方案。试试我的回答。希望它会有所帮助。 :)
可能值得看看这个问题：stackoverflow.com/questions/11997326/…

标签： java arrays

【解决方案1】：

我将通过创建原始ArrayList 的副本然后对其进行排序来做到这一点，现在我将遍历原始ArrayList 并在排序后的ArrayList 上获取它们的索引。这是我想出的：

//Initialization
ArrayList<Float> origOrder = new ArrayList<Float>();
origOrder.add(new Float(.43423));
origOrder.add(new Float(.43423));
origOrder.add(new Float(.2132));
origOrder.add(new Float(.3242));

//Copy original ArrayList
ArrayList<Float> sortedOrder = new ArrayList<Float>(origOrder);

//Remove duplicates
HashSet hs = new HashSet();
hs.addAll(sortedOrder);
sortedOrder.clear();
sortedOrder.addAll(hs);

//Sort copy in descending order
Collections.sort(sortedOrder, Collections.reverseOrder());

//ArrayList for result
ArrayList<Integer> result = new ArrayList<Integer>();

//For each float in the original ArrayList
for (Float f : origOrder) {

    //Add their index in the sorted order to the result list, plus 1 to start with 1
    result.add(sortedOrder.indexOf(f) + 1);
}

System.out.println(result);

输出如下：

[1, 1, 3, 2]

希望这会有所帮助。

【讨论】：

【解决方案2】：

如果你想做一个descending array，这里是代码：

Arrays.sort(data, Collections.reverseOrder());

注意：您需要 .reverseOrder 使其降序而不是升序

索引现在是您的0,1,2,3,4 ... etc

如果您想让相同的数字成为相同的索引，则必须创建另一个数组并通过删除重复元素自己完成

【讨论】：

为什么是.reverseOrder()？
因为它首先对ascending 最小值进行排序。因此，使其反转首先具有最大的价值
你能在你的回答中通过这个吗？
扔？我确实说“做一个 desc 数组”，但我可以让它更明确

【解决方案3】：

最好的方法是创建一个私有类 Elem {double val, int posInArray}，然后在 val 字段上创建一个 Comparator。排序你的元素数组，你也无法取回排序后的位置信息

【讨论】：

【解决方案4】：

这是我已经写过的一门课：

public class HighValueTable
{    
    public final int size;
    private final int[] position;
    private final double[] value;
    private int count = 0;

    public HighValueTable(int numberOfValues)
    {
        this.size = numberOfValues;
        this.position = new int[size];
        this.value = new double[size];  
    }

    public void insert(double valueToInsert, int positionOfNewValue)
    {
        int i;
        i = (count > size) ? count++ : size - 1;
        if (valueToInsert > value[i]) {
            while ((i > 0) && valueToInsert > value[i-1]) {
                value[i] = value[i-1];
                position[i] = position[i-1];
                --i;
            }
            this.position[i] = positionOfNewValue;
            this.value[i] = valueToInsert;
        }
    }

    public double getValue(int index)
    {
        return value[index];
    }

    public int getPosition(int index)
    {
        return position[index];
    }

    public void print()
    {
        System.out.println("[Value] : [Position]");
        for (int pos = 0; pos < size; ++pos) {
            System.out.println(getValue(pos) + " : " + position[pos]);
        }
    }
}

和一个实现：

double[] array = {.43423, .2132, .3242,};
HighValueTable hvt = new HighValueTable(array.length);

for (int i = 0; i < array.length; ++i)
    hvt.insert(array[i], i);

int[] array2 = new int[array.length];

for (int i = 0; i < array.length; ++i)
    array2[i] = hvt.getPosition(i) + 1; // +1 because of zero-based arrays

for (int i : array2)
    System.out.println(i);

并不完全严重。只是想我会分享

【讨论】：