C++ 根据一个向量对多个向量进行排序

我有四个向量，包含圆心上的x，y，半径和重量信息。我想按照重量的顺序（从高到低）对它们进行排序，但我真的不知道如何或从哪里开始。我可以把所有的向量放在一个

Eigen:：Tensor

中，以将收集到的数据保存在一个4d矩阵中，如果这样有帮助的话。但除此之外我不知道

每一个向量包含134个元素，但由于只需要对其中一个进行排序，这意味着排序算法并不重要

---

有人知道从哪里开始吗？

也许首先重构代码并将四个向量转换为一个结构向量更有意义。 诸如此类：

struct CircleInfo
{
    int x, y, radius, weight;
};

std::vector<CircleInfo> circles;

此代码与用于比较两个圆的自定义函数一起使用。要按半径进行比较，您需要将其更新为将

c1.weight

与

c2.weight

进行比较，您可以执行以下操作

ranges::sort(ranges::view::zip(xs, ys, radiuses, weights),
             std::greater<>{}, // decreasing order
             [](const auto& t){ return std::get<3>(t); }); // Projection: use weight

ranges:：sort（ranges:：view:：zip（xs、ys、radius、weights），
std:：更大的{}，//降序
[]（const auto&t）{return std:：get（t）；}）；//投影：使用重量

---

但是使用class

Circle

是有意义的，这样可以避免压缩数组，并允许更短的投影。

您可以创建第五个索引向量，根据4个向量中的一个对索引向量进行排序，然后在O（n）时间内对所有4个向量重新排序（也可以对索引向量进行排序）。示例：根据其中一个向量（ages向量）对3个向量进行排序。创建索引I的向量，然后根据A进行排序（使用lambda比较），然后通过撤销I中的“循环”，根据I对所有3个向量和I重新排序

#包括
#包括
#包括
#包括
#包括
int main（）
{
std:：vector A；//年龄
std:：vector N；//名称
std:：vector Z；//邮政编码
std:：vector I；//索引
int tA；
std：：字符串tN；
INTTZ；
A.推回（37）；
N.推回（“Ted”）；
Z.推回（54211）；
A.推回（21）；
N.推回（“约翰”）；
Z.推回（53421）；
A.推回（31）；
N.推回（“弗雷德”）；
Z.推回（52422）；
A.推回（21）；
N.推回（“Sam”）；
Z.推回（51422）；
//显示向量
对于（size_t i=0；istd：：你能使用普通的内置自定义比较函数吗？提示：与其有4个并行数组，为什么不创建一个具有4个属性的对象，然后创建一个这些对象的数组。然后这变得非常简单，你可以使用：。创建具有这4个属性的类的对象向量，然后对“对象”进行排序基于权重值。这么简单，请看：我真的很喜欢这一个。我可能以后也能从结构中的数据中获得使用。谢谢你，Pavel。我如何不必手动为每个点创建一个新的CircleInfo结构？我想我必须以某种方式使用
new
，但我不明白wWorks真的。@asdfghjkl您可以创建CircleInfo而无需使用动态分配：
CircleInfo ci12={1,1,1}；
其中值为
x，y，radius，weight
。然后您可以使用
push_-back:circles.push_-back（ci1）将CircleInfo结构添加到向量中
我可能只是没有正确理解它，但我有134个点，每个点都需要放在一个结构中。这是我的函数：我有一个3d矩阵（
张量
）包含圆所在位置的投票。如果投票>=阈值，则它们将被替换为1，如果不是，则被替换为0，因此局部最大值标记为1。然后计算x、y、半径和权重。但我无法将结构推入向量。我得到以下错误：`error C2664'CircleData:：CircleData（CircleData&&）“：无法将参数1从'CircleData*'转换为'const CircleData&'抱歉，尽管我一开始不理解这些错误，但有时我不得不阅读它们。我应该写
圈。改为放回（数据）；
。这就解决了问题。谢谢你，rcgldr。
before sort circles[0].radius: 3
after sort circles[0].radius: 1

ranges::sort(ranges::view::zip(xs, ys, radiuses, weights),
             std::greater<>{}, // decreasing order
             [](const auto& t){ return std::get<3>(t); }); // Projection: use weight

#include <algorithm>
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>

int main()
{
    std::vector <int> A;                // ages
    std::vector <std::string> N;        // names
    std::vector <int> Z;                // zip codes
    std::vector <size_t> I;             // indices
    int tA;
    std::string tN;
    int tZ;

    A.push_back(37);
    N.push_back("Ted");
    Z.push_back(54211);
    A.push_back(21);
    N.push_back("John");
    Z.push_back(53421);
    A.push_back(31);
    N.push_back("Fred");
    Z.push_back(52422);
    A.push_back(21);
    N.push_back("Sam");
    Z.push_back(51422);
    // display the vectors
    for(size_t i = 0; i < A.size(); i++)
        std::cout << std::setw(6) << N[i]
            << std::setw(8) << Z[i]
            << std::setw(4) << A[i] << std::endl;
    std::cout << std::endl;
    // initialize the vector of indices
    for(size_t i = 0; i < A.size(); i++)
        I.push_back(i);
    // sort I according to A
    std::stable_sort(I.begin(), I.end(),
        [&A](size_t i, size_t j) {return 
        A[i] < A[j];});
    // reorder A, N, Z in place also restore I
    // time complexity is O(n)
    for(size_t i = 0; i < A.size(); i++){
        size_t j, k;
        if(i != I[i]){
            tA = A[i];
            tN = N[i];
            tZ = Z[i];
            k = i;
            while(i != (j = I[k])){
                A[k] = A[j];
                N[k] = N[j];
                Z[k] = Z[j];
                I[k] = k;
                k = j;
            }
            A[k] = tA;
            N[k] = tN;
            Z[k] = tZ;
            I[k] = k;
        }
    }
    // display the sorted vectors
    for(size_t i = 0; i < A.size(); i++)
        std::cout << std::setw(6) << N[i]
            << std::setw(8) << Z[i]
            << std::setw(4) << A[i] << std::endl;
    return 0;
}