Как печатать индексы 10 наименьших значений в массиве

Вместо того, чтобы сортировать голые значения, отсортируйте пары (value, index) по отношению к value. Затем вы просто берете первые 10 пар, и у вас есть 10 исходных индексов.

Например, вы хотите отсортировать:

6 2 7 4

Составление (value, index) пар:

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

Сортировка по value:

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

Создайте простой класс для хранения двух целых чисел или используйте дженерики для любого значения:

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

И используйте Collections.sort.

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

Вы можете сделать это с помощью слегка измененной быстрой сортировки, сортируя массив, если вы также замените массив индексов, это поможет

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

короткое решение:

1. Создайте массив индексов (простой цикл for для инициализации).

2. Отсортируйте этот массив индексов с помощью пользовательской функции сравнения, которая сравнивает значения индекса в другом массиве. Примечание: используйте стабильную сортировку, если вы хотите печатать индексы по порядку.

3. Повторить массив отсортированных индексов, распечатать индексы и подсчитать различные значения (увеличить счетчик при изменении значения), остановить, когда счетчик станет равным 11.