Сортировка подобранных массивов в Java

Кажется, что самая чистая вещь сделать состояла бы в том, чтобы создать пользовательский класс свойства, который реализует Сопоставимый. Например:

class Color implements Comparable {
  private int number;
  private int color;

  // (snip ctor, setters, etc.)

  public int getNumber() {
    return number;
  }
  public int getColor() {
    return color;
  }

  public int compareTo(Color other) {
    if (this.getNumber() == other.getNumber) {
      return 0;
    } else if (this.getNumber() > other.getNumber) {
      return 1;
    } else {
      return -1;
    }
  }
}

Тогда можно разделить алгоритм сортировки от логики упорядочивания (Вы могли использовать Collections.sort, если Вы используете Список вместо массива), и самое главное, Вы не должны будете волноваться о так или иначе вытаскивании двух массивов из синхронизации.

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

extra = [0,1,...,numbers.length-1]

Тогда Вы могли отсортировать этот дополнительный массив с помощью Arrays.sort () с пользовательским компаратором (что, при сравнении элементов i и j действительно сравнивает числа [дополнительный [я]] и числа [дополнительный [j]]). Этот путь после сортировки дополнительного массива, дополнительного [0], содержал бы индекс самого маленького количества и, поскольку числа и цвета не перемещались, соответствующий цвет.
Это не очень хорошо, но это сделало задание, и я не могу действительно думать о более легком способе сделать это.

Как примечание стороны, на конкуренции я обычно нахожу, что C++ обработал по шаблону пар и хорошие необходимые карты;)

Почему бы не представить объект представить число и цвет и реализовать компаратор функционируют для этого?

кроме того, Вам действительно нужен массив, почему бы не использовать что-то полученное из Набора?

Мне нравится решение @tovare. Сделайте массив указателей:

int ptr[] = { 1, 2, 3 };

и затем когда Вы отсортируете на числах, подкачайте значения в ptr вместо в числах. Тогда доступ через массив ptr, как

for (int i = 0; i < ptr.length; i++)
{
   printf("%d %d\n", numbers[ptr[i]], colors[ptr[i]]);
}

Обновление: хорошо, кажется, что другие победили меня к этому. Никакой XP для меня.

Иллюстрирование в качестве примера с помощью третьего индексного массива. Не уверенный, если это - лучшая реализация.

    import java.util.*;

public class Sort {

    private static void printTable(String caption, Integer[] numbers, 
                Integer[] colors, Integer[] sortOrder){

        System.out.println(caption+
                "\nNo   Num   Color"+
                "\n----------------");

        for(int i=0;i<sortOrder.length;i++){
            System.out.printf("%x    %d     %d\n", 
                    i,numbers[sortOrder[i]],colors[sortOrder[i]]);

        }
    }


    public static void main(String[] args) {

        final Integer[] numbers = {1,4,3,4,2,6};
        final Integer[] colors  = {0x50,0x34,0x00,0xfe,0xff,0xff};
        Integer[] sortOrder = new Integer[numbers.length];

        // Create index array.
        for(int i=0; i<sortOrder.length; i++){
            sortOrder[i] = i;
        }
        printTable("\nNot sorted",numbers, colors, sortOrder);

        Arrays.sort(sortOrder,new Comparator<Integer>() {   
            public int compare(Integer a, Integer b){
                return numbers[b]-numbers[a];
            }});
        printTable("\nSorted by numbers",numbers, colors, sortOrder);

        Arrays.sort(sortOrder,new Comparator<Integer>() {   
            public int compare(Integer a, Integer b){
                return colors[b]-colors[a];
            }});
        printTable("\nSorted by colors",numbers, colors, sortOrder);
    }
}

вывод должен быть похожим на это:

Not sorted
No   Num   Color
----------------
0    1     80
1    4     52
2    3     0
3    4     254
4    2     255
5    6     255

Sorted by numbers
No   Num   Color
----------------
0    6     255
1    4     52
2    4     254
3    3     0
4    2     255
5    1     80

Sorted by colors
No   Num   Color
----------------
0    6     255
1    2     255
2    4     254
3    1     80
4    4     52
5    3     0

Один быстрый взлом должен был бы объединить два массива со сдвигами разряда. Сделайте массив longs таким образом, что старшие значащие 32 бита являются числом, и младшие значащие 32 цвет. Используйте метод сортировки и затем распакуйте.

Это было бы достаточно для кодирования собственного метода сортировки? Простой bubblesort, вероятно, был бы быстр, чтобы кодировать (и разобраться). Никакая потребность в дополнительных классах или компараторах.

Необходимо отсортировать массив цветов по его относительному объекту в массиве чисел. Определите компаратор, который сравнивает числа, и используйте это в качестве сравнения для массива цветов.

Самый простой способ сделать это в C, был бы bubblesort + двойные указатели. Конечно, самым быстрым был бы quicksort + два указателя. Конечно, 2-й указатель поддерживает корреляцию между двумя массивами.

я определил бы значения, которые хранятся в двух массивах как структура и используют структуру в едином массиве. Тогда используйте quicksort на нем. можно записать универсальную версию вида путем вызывания сравнить функции, которая может тогда быть записана для каждой структуры, но тогда Вы уже знаете что:)

Вы могли использовать вид () с пользовательским компаратором, если бы Вы сохранили третий массив с индексом и отсортировали на этом, оставив данные неповрежденными.

пример кода Java:

Integer[] idx = new Integer[numbers.length];
for( int i = 0 ; i < idx.length; i++ ) idx[i] = i;              
Arrays.sort(idx, new Comparator<Integer>() {
    public int compare(Integer i1, Integer i2) {                        
        return Double.compare(numbers[i1], numbers[i2]);
    }                   
});

// numbers[idx[i]] is the sorted number at index i
// colors[idx[i]] is the sorted color at index i

Примечание, которое необходимо использовать Integer вместо int или Вы не можете использовать пользовательский компаратор.