Java-对数组进行排序

我需要一些帮助

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

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

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

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

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

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

---

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

如果您想执行

降序数组

以下是代码：

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

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

索引现在是您的

0,1,2,3,4。。。etc

---

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

最好的方法是创建一个私有类Elem{double val，int posInArray}，然后在val字段上创建一个比较器。对元素数组进行排序，您也无法获取排序后的位置信息

我可以通过创建原始

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

---

希望这能有所帮助。

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

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

公共类高值表
{    
公共最终整数大小；
私人最终职位；
私人最终双[]值；
私有整数计数=0；
公共高价值表（int numberOfValues）
{
this.size=numberOfValues；
this.position=新整数[大小]；
this.value=新的双精度[尺寸]；
}
公共无效插入（双值插入，新值的int位置）
{
int i；
i=（计数>大小）？计数++：大小-1；
if（valueToInsert>value[i]）{
而（（i>0）和&valueToInsert>value[i-1]）{
值[i]=值[i-1]；
位置[i]=位置[i-1]；
--一,；
}
位置[i]=新值的位置；
this.value[i]=valueToInsert；
}
}
公共双getValue（int索引）
{
返回值[索引]；
}
公共整型getPosition（整型索引）
{
返回位置[索引]；
}
公开作废印刷品（）
{
System.out.println（“[Value]：[Position]”）；
用于（int pos=0；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);

double[]数组={.43423.2132.3242，}；
HighValueTable hvt=新的HighValueTable（array.length）；
对于（int i=0；i

---

不完全严重。我只是想分享一下

为什么

[1,3,2]

？为什么不

[1,2,3]

？@BitNinja我想那是个打字错误不，不是打字错误。这是因为我必须这样做。我的代码目前非常草率。@Sameer，我已经想出了一个解决方案。试试我的答案。希望能有所帮助。：）也许值得一看这个问题：为什么.reverseOrder（）？因为它首先对

升序

最小值进行排序。所以，让它倒转，首先是最大的价值。你能在回答中通过这个吗？扔吗？我确实说过“做一个描述数组”，但我可以让它更明确

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