根据一个向量对多个向量排序

Sorting multiple vectors according to one vector

本文关键字：向量 排序 一个      更新时间：2023-10-16

我有四个圆圈中包含x，y，半径和权重信息的向量。我想按重量顺序(最高到最低(对它们进行排序，但我真的不知道如何或从哪里开始。如果有帮助，我可以将所有向量放在Eigen::Tensor中，以将数据收集到一个4D矩阵中。但是除此之外，我不知道。

每个向量都包含134个元素，但是由于其中只有一个必须进行排序，这意味着分类算法并不重要。

有人有提示从哪里开始吗？

您可以创建第五个索引向量，根据4个向量之一对索引向量进行排序，然后在o中重新排序所有4个向量(以及对o(索引的向量((n(时间。根据其中一个(年龄向量(对3个向量进行排序的示例。创建索引i的向量是由A(使用lambda比较(进行排序的，然后，通过删除I。

中的"周期"，将所有3个向量和我通过i重新排序。 
#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;
}

ranges-v3，您可以做

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

演示

但是，让Circle类是有道理的，这将避免将阵列拉开，并允许较短的投影。

也许首先重组代码并将四个向量转换为结构的一个矢量更有意义。这样的东西：

struct CircleInfo
{
    int x, y, radius, weight;
};
std::vector<CircleInfo> circles;

然后，如果要按半径进行排序：

#include <vector>
#include <algorithm>
#include <iostream>
struct CircleInfo
{
    int x, y, radius, weight;
};
int main()
{
    std::vector<CircleInfo> circles;
    CircleInfo ci1 = { 1,1,1,1 };
    CircleInfo ci2 = { 3,3,3,3 };
    circles.push_back(ci2);
    circles.push_back(ci1);
    std::cout << "before sort circles[0].radius: " << circles[0].radius << std::endl;
    std::sort(circles.begin(), circles.end(), [](const CircleInfo& c1, const CircleInfo& c2) {
        return c1.radius < c2.radius;
    });
    std::cout << "aftern sort circles[0].radius: " << circles[0].radius << std::endl;
}

输出：

before sort circles[0].radius: 3
after sort circles[0].radius: 1

此代码使用std ::与自定义功能进行比较两个圆圈的strat。要通过半径进行比较，您需要将其更新以将c1.weight与c2.weight进行比较。

相关文章：