Создать массив из индексов значений другого массива

Отсюда возьмите:

//Функция сортировки массива
void SortArray
 (
 int     OptimizeMethod,
 int     stringCount,
 int     rowCount,
 double &mass[][1000]
 )
{
  //-----------------------Переменные-------------------------------------
  int cnt=1, i = 0, u = 0;
  double          massTemp[][1000];
  ArrayResize    (massTemp,stringCount);
  ArrayInitialize(massTemp,0.0);

  int             temp0[];
  ArrayResize    (temp0,rowCount);
  ArrayInitialize(temp0,0);
  int    t0=0;
  double          temp1[];
  ArrayResize    (temp1,rowCount);
  ArrayInitialize(temp1,0.0);
  double t1=0.0;
  //----------------------------------------------------------------------

  //Проставим индексы во временном массиве temp2 и 
  //...скопируем первую строку из сортируемого массива
  for(i=0;i<rowCount;i++)
  {
    temp0[i] = i;
    temp1[i] = mass[0][i];
  }
  if(OptimizeMethod==1)
  {
    while(cnt>0)
    {
      cnt=0;
      for(i=0;i<rowCount-1;i++)
      {
        if(temp1[i]>temp1[i+1])
        {
          //-----------------------
          t0 = temp0[i+1];
          t1 = temp1[i+1];
          temp0   [i+1] = temp0[i];
          temp1   [i+1] = temp1[i];
          temp0   [i] = t0;
          temp1   [i] = t1;
          //-----------------------
          cnt++;
        }
      }
    }
  }
  else
  {
    while(cnt>0)
    {
      cnt=0;
      for(i=0;i<rowCount-1;i++)
      {
        if(temp1[i]<temp1[i+1])
        {
          //-----------------------
          t0 = temp0[i+1];
          t1 = temp1[i+1];
          temp0   [i+1] = temp0[i];
          temp1   [i+1] = temp1[i];
          temp0   [i] = t0;
          temp1   [i] = t1;
          //-----------------------
          cnt++;
        }
      }
    }
  }
  //Создадим отсортированный массив по полученным индексам
  for(i=0;i<stringCount;i++)
    for(u=0;u<rowCount;u++)
      massTemp[i][u]=mass[i][temp0[u]];
  //Скопируем отсортированный массив обратно
  for(i=0;i<stringCount;i++)
    for(u=0;u<rowCount;u++)
      mass[i][u]=massTemp[i][u];
}
//————————————————————————————————————————————————————————————————————————

Делаете функцию сортировки, которая действует по следующей логике ...

находит минимум массива и присваивает в переменную А,

за одно присваивает индекс в массив IndexArray i++

далее ищет минимальное значение большее чем А(или равное А но с отличающимся индексом),

за одно присваивает индекс в массив IndexArray i++

это уже как видите цикл, выход из цикла когда в А будет присвоен максимум массива(ну или пока всю длинну не прелопатит).

Для joo: "Профессор! Я здесь! У печки! Спасибо, но это пока не по мои зубы... :)
Для Urain: Я пытался сделать такую функцию через поиск наибольшего значения, но не смог правильно организовать цикл... :(

Я давал функцию сортировки массива по второму измерению.

Из неё, мановением руки, путем кастрации, получается то что Вам нужно:

void Sort1Darray
 (
 int     SortMethod,
 double &mass     [],
 int    &indexMass[]
 )
{
  //-----------------------Переменные-------------------------------------
  int cnt=1, i = 0, u = 0;
  int ElementCount=ArraySize(mass);

  double          massTemp[];
  ArrayResize    (massTemp,ElementCount);
  ArrayInitialize(massTemp,0.0);

  int    t0=0;
  double          temp1[];
  ArrayResize    (temp1,ElementCount);
  ArrayInitialize(temp1,0.0);
  double t1=0.0;
  //----------------------------------------------------------------------

  //Проставим индексы во временном массиве temp2 и 
  //...скопируем элементы из сортируемого массива
  for(i=0;i<ElementCount;i++)
  {
    indexMass[i] = i;
    temp1[i] = mass[i];
  }
  if(SortMethod==1)
  {
    while(cnt>0)
    {
      cnt=0;
      for(i=0;i<ElementCount-1;i++)
      {
        if(temp1[i]>temp1[i+1])
        {
          //-----------------------
          t0 = indexMass[i+1];
          t1 = temp1[i+1];
          indexMass   [i+1] = indexMass[i];
          temp1   [i+1] = temp1[i];
          indexMass   [i] = t0;
          temp1   [i] = t1;
          //-----------------------
          cnt++;
        }
      }
    }
  }
  else
  {
    while(cnt>0)
    {
      cnt=0;
      for(i=0;i<ElementCount-1;i++)
      {
        if(temp1[i]<temp1[i+1])
        {
          //-----------------------
          t0 = indexMass[i+1];
          t1 = temp1[i+1];
          indexMass   [i+1] = indexMass[i];
          temp1   [i+1] = temp1[i];
          indexMass   [i] = t0;
          temp1   [i] = t1;
          //-----------------------
          cnt++;
        }
      }
    }
  }
  //Создадим отсортированный массив по полученным индексам
  for(u=0;u<ElementCount;u++)
    massTemp[u]=mass[indexMass[u]];
  //Скопируем отсортированный массив обратно
  for(u=0;u<ElementCount;u++)
    mass[u]=massTemp[u];
}
//————————————————————————————————————————————————————————————————————————

Получите отсортированный одномерный массив mass[] и индексы элементов в indexMass[]

Если не нужно получать отсортированный массив, уберите два последних for()

Вызываете так:

Sort1Darray(SortMethod, MyArray, IndexArray);

joo! Огромное спасибо за оперативность и содержательность! Я приспособил под свои нужды Вашу функцию. Всё работает!!!

Массив я создал, это индексы приоритета. Теперь мне нужно в цикле согласно этим индексам организовать очерёдность выволнения функций.

Имеем деять функций, они исполняются в цикле:

for (i = 1; i <= 10; i++)  
{          
    if (i == 1)          
    {function1();}          
    if (i == 2)          
    {function2();}  
------    

------          
    if (i == 10)          
    {function10();}  
}

и мне нужно в соответствии со значениями моего массива  IndexArray[] организовать очерёдность выполнение этих функций. То, что я сотворил при ближайшем рассмотренни оказалось не тем, что хотелось бы иметь... Не поможете???

После исполнения всей очереди, очередь формируется заново - перезаполняется массив IndexArray[] и опять по кругу. 

switch( ) Вам в помощь. Пробуйте. Не получится - спрашивайте.

Спасибо за идею! Буду ковыряться.

joo! Всё получилось значительно проще:

    for (li_int_ind = 0; li_int_ind < Size (ArrayIndex); li_int_ind++)
    {
        li_int_f = ArrayIndex[li_int_ind];
        switch (li_int_f)
        {
            case 1: function1(); break;
            case 2: function2(); break;
            -------------
            
            -------------
            case 10: function10(); break;
        }
    }

Ещё раз огромное спасибо!!! 

на здоровье