вид массивов и их положение

Question

У меня проблема с сортировкой.

У меня есть два массива

int a[] ={index1,index2,index3...indexI};
int b[] ={num1,num2,num3.......numI};

Массив b [] имеет числа в случайном порядке, но их позиция соответствует позиции в [].Например, num1 - это значение index1, num2 - это значение index2.

Проблема в следующем:

Мне нужно отсортировать элементы b [] в порядке убывания, в то же время янеобходимо переместить положение элементов a [] в соответствии с отсортированным порядком b [].

Я могу отсортировать b [] в порядке убывания, используя один из алгоритмов сортировки, но я не могу обработать одновременное перемещениеэлементы a [] в соответствии с изменением положения b [].Мой окончательный вывод, который я ожидаю - это индексы [], расположенные в порядке убывания их значений в b [].

Пожалуйста, помогите.

Спасибо

Answer 1

int a[] ={index1,index2,index3...indexI};
int b[] ={num1,num2,num3.......numI};
int c[] = {{num1, index1}, {num2, index2}...{indexI, numI}}
sort(c);
for i = 0 to c.len
  print c[i][1]

В c ++ я бы использовал вектор пар. На других языках вы можете использовать структуру.

Answer 2

Если я правильно понял, вы хотите что-то вроде этого a = [0 1 2];b = [5 2 8] и после сортировки a = [1 0 2];b = [2 5 8].

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

например.смена двух позиций (псевдокод)

swap(i, j): // i, j - indexes
   (b[i], b[j]) = (b[j], b[i]) // swap values
   (a[i], a[j]) = (a[j], a[i]) // swap the indexes

Answer 3

Используя qsort, вы отсортируете массив a, используя следующее выражение сравнения:

b[*(int*)elem1] - b[*(int*)elem2]

, где elem1 и elem2 - два аргумента-указателя на функцию компаратора (пусть b будет видна функцией).

Это оставит массив b без изменений, а b [a [i]] даст b элементов в порядке убывания.

Answer 4

Это показывает один из недостатков использования параллельных массивов вместо массива struct. Простым решением было бы преобразовать ваш код в

 struct {int index, num;} a[] = {{index1, num1},{index2, num2}, ...};

Если ваша кодовая база уже интенсивно использует параллельные массивы, вы можете написать сортировку, которая знает о таких трудностях. Вы можете передать ему массив массивов, а не один, и написать сортировку для выполнения перестановок в каждом массиве, выполняя только сравнения первого. Другими словами:

void sort_pa(void **arrays/*NULL-terminated*/, int len,int size, int(*cmp)(...)))

Что бы вы потом использовали:

int a[] ={index1,index2,index3...indexI};
int b[] ={num1,num2,num3.......numI};
int *c[] = {b, a, NULL};

sort_pa(c, I, sizeof **c, cmp);

Answer 5

Вы можете сделать это двумя путями: во-первых, отсортировать a, используя ваш любимый алгоритм сортировки, но вместо сравнения a[i] с a[j] напрямую, сравните b[a[i]] с b[a[j]]. Теперь переставьте b в соответствии с индексами в a - и все готово.

Второй шаг может выглядеть следующим образом (в псевдокоде):

var c = new int[b.length]
for (int i = 0 ; i != a.length ; i++)
    c[i] = b[a[i]]
b = c

Answer 6

После сортировки b вы можете отсортировать a с помощью функции сравнения, которая ищет значения в b.

// assuming b is visible at the module level, you can pass this to qsort
int compare_by_indexing_into_b(void const *a, void const *b)
{
    int i = *(int const *)a;
    int j = *(int const *)b;

    return b[i] - b[j];
}