获取数组中 n 个最小元素的索引

Question

我有一个 int 数组 int[] myArray = new int[100]; 并且想要获取最小 10（任意 n）个元素的索引。我该怎么做？

Answer 1

排序数组然后选择 10 很简单，但它会是 O(n log n)，如果你不想重新排序初始数组，你也需要复制一份。

一个更好的主意是使用最大堆（或优先级队列），它会在您插入元素时自动对元素进行排序，这样最大的元素就是根节点。沿着数组走，继续放入元素，直到达到 10；然后，对于每个后续元素，只需检查它是否小于堆中最大的元素（恒定时间检查），如果是，则将其弹出并插入新元素。当你遍历整个数组时，里面剩下的 10 个东西就是你的最小元素。这会让你得到 O(n log 10) == O(n) 的结果，因为每次插入堆只花费 O(log 10)。

Java 的 Priority Queue 实现默认是最小队列，因此您需要传入一个反转排序的 Comparator。有关如何执行此操作的示例，请参阅this question。如果您想在最后获取索引，您还需要创建一个包含 (value, index) 对的自定义对象。

Answer 2

创建一个包含数字和索引的对象，然后创建这些对象的数组，然后执行 Array.Sort(arrayset[],comparator)java docs。然后你就可以从排序后的数组中挑选出前 x 项。

编辑： 像这样的东西...... [我用这个根据'距离'进行排序

import java.util.Arrays;
import java.util.Comparator;

public class NearestObject
{
    public NearestObject(int position, int distance)
    {
         this.Position = position;
         this.Distance = distance;
    }
    public int Position = 0;
    public int Distance = 0;

    public static NearestObject[] SortDistance(NearestObject[] items)
    {
        Arrays.sort(items, new DistanceSort());
        return items;
    }

}

class DistanceSort implements Comparator<NearestObject>
{
    public int compare(NearestObject o1, NearestObject o2)
    {
        return o1.Distance - o2.Distance;
    }
}

Answer 3

直接的解决方案是遍历数组并维护您找到的 n 个最小元素及其索引的列表。这是一个 O(N) 的解决方案，在大多数情况下都可以接受。我猜这是家庭作业，你必须有比 O(N) 更好的东西。

Answer 4

按索引排序并返回前 10 个

首先创建一个结构来保存索引和值：

class IndexValue {
   final int i;
   final int v;
}

然后用这个新结构创建一个数组：

IndexValue[] array = new IndexValue[myArray.length];
for( int i = 0 ; i < array.length ; i++ ) {
    array[i] = new IndexValue( i, myArray[i] );
}

最后排序，取前N个元素

Arrays.sort( array ); // you'll need to implement Comparator though 

for( int i = 0 ; i< 10 ;i++ ) {
    System.out.print( array[i] );
}

这是完整的工作代码：

import java.util.Arrays;
import java.util.Random;
import java.util.Comparator;
import static java.lang.System.out;

class IndexValue {
   final int i,v;

   public IndexValue( int i, int v ) {
       this.i = i;
       this.v = v;
   }
}
public class SortByIndex {
    public static void main( String [] args ) {

        Random random = new Random();

        int [] myArray = new int[100];
        IndexValue[] array = new IndexValue[myArray.length];

        // Fill the array 
        for( int i = 0 ; i < 100; i++ ) {
            myArray[i] = random.nextInt();
            array[i] = new IndexValue( i, myArray[i] );
        }

        // Sort it 
        Arrays.sort( array, new Comparator<IndexValue>(){
            public int compare( IndexValue a, IndexValue b ){
                return a.v - b.v;
            }
        });

        // Print it
        out.println("Top:");
        for( int i = 0 ; i < 10 ; i++ ) {
            out.println( String.format("array[%d]=%d",  array[i].i, array[i].v ));
        }

    }
}

Answer 5

您可以对数组进行排序，循环前 10 个元素，然后为每个元素在数组中搜索它所在的位置...也许这不是更有效的方法，但它更容易。

Answer 6

如果您正在寻找一个实用的答案（相对于实际的排序算法等），那么只需使用 HashMap 或 PriorityQueue。如果速度不是问题，试试这个简单的算法。它比 PriorityQueue 更容易，因为您不需要自定义对象：

HashMap<Integer, ArrayList<Integer>> indexMap = new HashMap<Integer, ArrayList<Integer>>();

填写 indexMap 以便我们可以获取数组中任何给定数字的索引

for (int index = 0; index <= array.size; index++) {
   if (indexMap.get(array[index]) == null) { // Prime it with an ArrayList
      indexMap.put(array[index], new ArrayList<Integer>());
   }

   indexMap.get(array[index]).add(index);
}

对于数组中最小的 n 个数，打印出它们的索引。

Arrays.sort(array);
for (int index = 0; index <= n; index++) {
   System.out.println(indexMap.get(array[index]).remove(0));
}