基于另一个就地阵列对一个阵列进行排序 我用C++编写代码（用C++ 11标准），我有两个大数组的内置类型，我想根据第一个排序第二个。 以下是一个例子： A = {1, 5, 4, 3, 6, 2}; B = {1, 2, 3, 4, 5, 6};

排序后：

A = {1, 2, 3, 4, 5, 6};
B = {1, 6, 4, 3, 2, 5};

这就好像每个元素

B[i]

都附加到元素

A[i]

上，您只需对数组

A

进行排序。因此

B

中的元素根据

A

中相应的元素移动。我知道这个问题已经被问了一遍又一遍，但我遇到的唯一解决办法是使用

配对
。但考虑到数组很大，为成对数组和来回复制数组分配内存需要相当长的时间。
但我相信排序可以就地完成，即只使用
O（1）
内存。事实上，如果std：：sort允许服装交换，那就没问题了。因为我假设这是排序算法使用的唯一比较器之外的东西

A = vector<double>(1e6);  // some random numbers
B = vector<double>(1e6);  // some random numbers
Comp comp(&A,&B);
Swap swap(&A,&B);
costume_sort(A,B,comp,swap);   // some sort function that can take costume swap and compare

class Comp {
   vector<double> *A;
   vector<double> *B;
   Comp(vector<double> *A, vector<double> *B) : A(A),B(B) {};

   bool compareTo(size_t i, size_t j) { return A->at(i) < A->at(j); };
};


class Swap {
   vector<double> *A;
   vector<double> *B;
   Swap(vector<double> *A, vector<double> *B) : A(A),B(B) {};

   void swapFnc(size_t i, size_t j) { swap(A->at(i), A->at(j));swap(B->at(i), B->at(j)); };
};

A=vector（1e6）；//一些随机数
B=向量（1e6）；//一些随机数
薪酬薪酬（A&B）；
互换（A和B）；
服装分类（A、B、comp、swap）；//一些可以进行服装交换和比较的排序函数
班级薪酬{
向量*A；
向量*B；
Comp（向量*A，向量*B）：A（A），B（B）{}；
bool compareTo（size_t i，size_t j）{返回A->at（i）at（j）；}；
};
类交换{
向量*A；
向量*B；
交换（向量*A，向量*B）：A（A），B（B）{}；
无效交换（大小i，大小j）{swap（A->at（i），A->at（j））；swap（B->at（i），B->at（j））；}；
};

STL或其他库中是否有任何函数可以做到这一点？这是我试图在这里解释的想法的一种伪代码。显然，这并不精确，但我希望我的意思很清楚。
您可以根据类似于相关帖子的索引进行排序：

它不是一个自定义的交换函数，可以分配更多的内存，但应该可以很好地执行

如果要定义类型，则可以重载
std：：swap
以执行所需操作。
否没有满足您要求的
std:
函数

尽管可以提供其自定义和functor，但它们使用（常量）引用来比较或交换项，而不是假设容器上的索引。实际上，这些函子对于非包含对象的比较和交换应该有意义。
根据指向a[]的指针排序数组对a[]和b[]重新排序的示例。因为使用了指针数组，所以compare函数只需要知道要比较的元素的类型。再排序就地代码的时间复杂度为O（n），每个存储在其排序位置放置一个值。请注意，指针数组在重新排序过程中恢复为其原始状态（&a[0]…&a[n-1]）

bool compare(const int *p0, const int *p1)
{
    return *p0 < *p1;
}

int main()
{
int a[8] = {7,5,0,6,4,2,3,1};
char b[8] = {'h','f','a','g','e','c','d','b'};
int *pa[8];
size_t i, j, k;
int ta;
char tb;
    // create array of pointers to a[]
    for(i = 0; i < sizeof(a)/sizeof(a[0]); i++)
        pa[i] = &a[i];
    // sort array of pointers to a[]
    std::sort(pa, pa+sizeof(a)/sizeof(a[0]), compare);
    // reorder a[] and b[] according to the array of pointers to a[]
    for(i = 0; i < sizeof(a)/sizeof(a[0]); i++){
        if(i != pa[i]-a){
            ta = a[i];
            tb = b[i];
            k = i;
            while(i != (j = pa[k]-a)){
                a[k] = a[j];
                b[k] = b[j];
                pa[k] = &a[k];
                k = j;
            }
            a[k] = ta;
            b[k] = tb;
            pa[k] = &a[k];
        }
    }
    for(i = 0; i < sizeof(a)/sizeof(a[0]); i++)
        std::cout << a[i] << ' ';
    std::cout << std::endl;
    for(i = 0; i < sizeof(b)/sizeof(b[0]); i++)
        std::cout << b[i] << ' ';
    std::cout << std::endl;
    return 0;
}

bool比较（常数int*p0，常数int*p1）
{
返回*p0<*p1；
}
int main（）
{
int a[8]={7,5,0,6,4,2,3,1}；
字符b[8]={'h'，'f'，'a'，'g'，'e'，'c'，'d'，'b'}；
int*pa[8]；
尺寸i，j，k；
int ta；
炭结核；
//创建指向[]的指针数组
对于（i=0；istd：：这似乎是一个基于链接的答案，你能用你的话解释一下如何将这些链接中的信息更详细地应用于这个问题吗n klas，ut menik nag'mirk talut。@LeFlou我在更新的问题中提供了一个例子。这就像你对A排序，B的每个元素都附加到A中相应的元素。（B中的元素
I
附加到A中的元素
I
）你真的希望两个向量都是
double
？还是一个
double
和一个
std:：size\u t
？@GuyGreer事实上，现在我正在处理一个
double
one
uint64\u t
。但我希望我可以忽略一个是整数的事实，以更通用的方式编写代码。但是如果有一个简洁的解决方案胡说，对于整数，我也很高兴知道这一点。看看标准库中建议添加的引用实现。考虑一个表，或者更好。