我想使用C / C ++以升序对数组进行排序。结果是一个包含元素索引的数组。每个索引都与排序数组中元素的位置相对应。

例子

Input:  1, 3, 4, 9, 6
Output: 1, 2, 3, 5, 4

编辑：我正在使用外壳排序过程。根据原始数组中最先出现的重复值来任意选择重复值索引。

更新：

尽管尽了最大的努力，但我仍无法为指针数组实现排序算法。当前示例将无法编译。

有人可以告诉我怎么了吗？

我非常感谢帮助！

void SortArray(int ** pArray, int ArrayLength) 
{
    int i, j, flag = 1;    // set flag to 1 to begin initial pass
    int * temp;    // holding variable orig with no *

    for (i = 1; (i <= ArrayLength) && flag; i++)
    {
        flag = 0;
        for (j = 0; j < (ArrayLength - 1); j++)
        {
            if (*pArray[j + 1] > *pArray[j])    // ascending order simply changes to <
            { 
                &temp = &pArray[j];    // swap elements
                &pArray[j] = &pArray[j + 1];    //the problem lies somewhere in here
                &pArray[j + 1] = &temp;
                flag = 1;    // indicates that a swap occurred.
            }
        }
    }
};

解决方案

回答

好吧，这里有一个简单的n ^ 2解决方案。

在python中：

newArray = sorted(oldArray)
blankArray = [0] * len(oldArray)
for i in xrange(len(newArray)):
  dex = oldArray.index(newArray[i])
  blankArray[dex]  = i

根据列表的大小，这可能会起作用。如果列表很长，则需要进行一些奇怪的并行数组排序，这看起来并不有趣，并且是在代码中引入额外错误的快速方法。

另请注意，以上代码在oldArray中采用唯一值。如果不是这种情况，则需要进行一些后期处理以解决约束值。

回答

由于我们使用的是C ++，所以我会这样做。 SortIntPointers函数可以是任何排序算法，重要的是它可以根据指针所指向的int对指针数组进行排序。完成此操作后，我们可以遍历指针数组并分配它们的排序索引，该索引将最终到达原始数组中的原始位置。

int* intArray; // set somewhere else
int arrayLen;  // set somewhere else  

int** pintArray = new int*[arrayLen];
for(int i = 0; i < arrayLen; ++i)
{
    pintArray[i] = &intArray[i];
}

// This function sorts the pointers according to the values they
// point to. In effect, it sorts intArray without losing the positional
// information.
SortIntPointers(pintArray, arrayLen);

// Dereference the pointers and assign their sorted position.
for(int i = 0; i < arrayLen; ++i)
{
    *pintArray[i] = i;
}

希望这已经足够清楚了。

回答

创建一个新数组，将值从0增大到n-1(其中n是要排序的数组的长度)。然后，根据旧数组中的值(由新数组中的值索引)对新数组进行排序。

例如，如果使用冒泡排序(易于解释)，则无需比较新数组中的值，而是在新数组中的值所索引的位置比较旧数组中的值：

function bubbleRank(A){
  var B = new Array();
  for(var i=0; i<A.length; i++){
    B[i] = i;
  }
  do{
    swapped = false;
    for(var i=0; i<A.length; i++){
      if(A[B[i]] > A[B[i+1]]){
        var temp = B[i];
        B[i] = B[i+1];
        B[i+1] = temp;
        swapped = true;
      }
    }
  }while(swapped);
  return B;
}

回答

好的，这是我在C ++中的尝试

#include <iostream>
#include <algorithm>

struct mycomparison
{
    bool operator() (int* lhs, int* rhs) {return (*lhs) < (*rhs);}
};

int main(int argc, char* argv[])
{
    int myarray[] = {1, 3, 6, 2, 4, 9, 5, 12, 10};
    const size_t size = sizeof(myarray) / sizeof(myarray[0]);
    int *arrayofpointers[size];
    for(int i = 0; i < size; ++i)
    {
        arrayofpointers[i] = myarray + i;
    }
    std::sort(arrayofpointers, arrayofpointers + size, mycomparison());
    for(int i = 0; i < size; ++i)
    {
        *arrayofpointers[i] = i + 1;
    }
    for(int i = 0; i < size; ++i)
    {
        std::cout << myarray[i] << " ";
    }
    std::cout << std::endl;
    return 0;
}

回答

使用boost :: lambda并行排序矢量...

std::vector<int> intVector;
   std::vector<int> rank;

   // set up values according to your example...
   intVector.push_back( 1 );
   intVector.push_back( 3 );
   intVector.push_back( 4 );
   intVector.push_back( 9 );
   intVector.push_back( 6 );

   for( int i = 0; i < intVector.size(); ++i )
   {
      rank.push_back( i );
   }

   using namespace boost::lambda;
   std::sort( 
              rank.begin(), rank.end(),
              var( intVector )[ _1 ] < var( intVector )[ _2 ] 
            );

   //... and because you wanted to replace the values of the original with 
   //    their rank
   intVector = rank;

注意：我使用vectorS而不是数组，因为它更清晰/更容易，而且我使用了C样式索引，该索引从0开始计数，而不是从1开始。