Java 如何打印数组中10个最小值的索引

我需要从数组中选择10个最小的数字（有2000个项目）并打印它们的索引

起初，我尝试对这个数组进行排序，并打印值数组[0到9]。这是最小的数字，但我丢失了这些值的索引，它们有一个非排序数组

第二个选项是尝试使用treeMap，它工作得很好，但当我有两个相等的键时，它只打印其中一个，但我需要打印两个键

将代码与treeMap一起使用的示例：

  TreeMap<Integer, String> treemap = new TreeMap<Integer, String>();

  treemap.put(2, "two");
  treemap.put(1, "one");
  treemap.put(3, "three");
  treemap.put(6, "six");
  treemap.put(6, "six2");
  treemap.put(5, "five");      

  Collection<String> coll=treemap.values();
  System.out.println("Value of the collection: "+coll);  

TreeMap TreeMap=newtreemap（）；
树映射put（2，“2”）；
树状图put（1，“一”）；
树映射put（3，“三”）；
树映射put（6，“6”）；
treemap.put（6，“6个2”）；
树状图put（5，“5”）；
集合coll=treemap.values（）；
System.out.println（“集合值：+coll”）；

到目前为止，我还没有使用treeMap，所以有可能存在一些简单的方法来修复它。还是最好用别的东西

如果有任何帮助，我将不胜感激

这是最小的数字，但我丢失了这个值的索引，这 他们有一个未排序的数组

那么为什么不创建一个类来保存这些索引呢？ 然后，只需按值对数组进行排序，就可以得到关联的索引

class MyClass implements Comparable<MyClass>{
    private int index;
    private int value;

    public MyClass(int i, int v){
       this.index = i;
       this.value = v;
    }

    @Override
    public String toString(){
        return "Index: "+index+" Value: "+value;
    }

    @Override
    public int compareTo(MyClass m) {
        return value - m.value;
    }
}

---

输出（使用第二种

比较方法）：

不要对裸值进行排序，而是根据
值对
（值，索引）
对进行排序。
然后，只取前10对，就有10个原点索引

例如，您要排序：

6 2 7 4

制作
（值、索引）
对：

(6, 0) (2, 1) (7, 2) (4, 3) 

关于
值的排序
：

(2, 1) (4, 3) (6, 0) (7, 2) 

指数：

1 3 0 2

您使用
TreeMap
的方法很好。您必须进行的唯一修改如下所示：

class Pair implements Comparable<Pair> {
    int value;
    int index;

    @Override
    int compareTo(Pair other) { return value - other.value };
}

Map<Pair, String> map = new TreeMap<Pair, String>();

类对实现了可比较的{
int值；
整数指数；
@凌驾
int compareTo（Pair other）{返回值-other.value}；
}
Map Map=newtreemap（）；
您可以通过稍微修改的快速排序来实现这一点，同时对数组进行排序，如果您交换索引数组，也可以做到这一点

public class Quicksort 
{
    private int[] numbers;
    private int number;

    public void sort(int[] values) {
        if (values ==null || values.length==0){
           return;
        }
        this.numbers = values;
        number = values.length;
        quicksort(0, number - 1);
    }

    private void quicksort(int low, int high) {
        int i = low, j = high;
        int pivot = numbers[low + (high-low)/2];

        while (i <= j) {
            while (numbers[i] < pivot) {
                i++;
            }
            while (numbers[j] > pivot) {
               j--;
            }

            if (i <= j) {
                exchange(i, j);
                i++;
                j--;
            }
        }

        if (low < j)
            quicksort(low, j);
        if (i < high)
            quicksort(i, high);
    }

简短解决方案：

创建索引数组（循环初始化简单）

使用自定义比较函数对该索引数组进行排序，该函数比较其他数组中索引的值。注意：如果要按顺序打印索引，请使用稳定排序

迭代排序的索引数组，打印索引并计算不同的值（值更改时增加计数器），计数器变为11时停止

创建一个简单类来保存两个整数，或对任何值使用泛型：

class Item<T> { 
    public int index;
    public T value;
    public Item(int index, T value) {
        this.index = index;
        this.value = value;
    }
}

输出：

index: 3, value: -1
index: 0, value: 1
index: 2, value: 3
index: 4, value: 5
index: 1, value: 7

问题是“打印具有最小值的10个索引”（可能一些具有相同值的索引未打印），还是“打印具有10个最小值的索引”（可能超过10个，即使整个数组只有10个或更少的不同值），这是正确的。感谢更好的主题名称：）这将很容易阅读，并附有一些说明，澄清逻辑是否可以将其更改为双值？我所有更改答案的尝试都以错误告终。@PetrŠrámek是的，请参阅对答案的修改是否可以将其更改为双值？我所有更改它的尝试都以错误告终。@PetrŠrámek是的，当然，只需将值字段更改为原语
double
，并在类
double
中使用静态方法
compare
，即
int compareValue=double.compare（value，m.value）在
比较到
方法中。谢谢。。。在添加此评论之前，我尝试过它，但我可能有一些错误，因为现在它运行良好。@PetrŠrámek不客气。很酷，现在就可以了=）
public class Quicksort 
{
    private int[] numbers;
    private int number;

    public void sort(int[] values) {
        if (values ==null || values.length==0){
           return;
        }
        this.numbers = values;
        number = values.length;
        quicksort(0, number - 1);
    }

    private void quicksort(int low, int high) {
        int i = low, j = high;
        int pivot = numbers[low + (high-low)/2];

        while (i <= j) {
            while (numbers[i] < pivot) {
                i++;
            }
            while (numbers[j] > pivot) {
               j--;
            }

            if (i <= j) {
                exchange(i, j);
                i++;
                j--;
            }
        }

        if (low < j)
            quicksort(low, j);
        if (i < high)
            quicksort(i, high);
    }

    private void exchange(int i, int j) {
    int temp = numbers[i];
    numbers[i] = numbers[j];
    numbers[j] = temp;

    // NOTICE THIS exchange the indexes as well
    temp = index_numbers[i];
    index_numbers[i] = index_numbers[j];
    index_numbers[j] = temp;
    }
}

class Item<T> { 
    public int index;
    public T value;
    public Item(int index, T value) {
        this.index = index;
        this.value = value;
    }
}

double[] original = { 1.0, 7.0, 3.0, -1.0, 5.0 };

List<Item> l = new ArrayList<Item<Double>>();
for (int i = 0; i < original.length; i++)
    l.add(new Item<Double>(i, original[i]));

Collections.sort(l, new Comparator<Item<Double>>() {
    public int compare(Item o1, Item o2) {
        return Double.compare(o1.value, o2.value);
    }
});

for (int i = 0; i < 10 && i < l.size(); i++) {
    System.out.printf("index: %f, value: %f%n", 
              l.get(i).index, l.get(i).value);
}

index: 3, value: -1
index: 0, value: 1
index: 2, value: 3
index: 4, value: 5
index: 1, value: 7