根据一个向量对多个向量进行排序[重复]

Question

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

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

有人提示从哪里开始吗？

Answer 1

您可以创建第 5 个索引向量，根据 4 个向量之一对索引向量进行排序，然后在 O(n) 时间内重新排序所有 4 个向量（并对索引向量进行排序）。根据其中一个（年龄向量）对 3 个向量进行排序的示例。创建索引向量 I 然后根据 A 排序（使用 lambda 比较），然后通过撤消 I 中的“循环”，根据 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;
}

Answer 2

使用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

Demo

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

Answer 3

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

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

std::vector<CircleInfo> circles;

那么，如果你想sort by radius：

#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::sort 和自定义函数来比较两个圆。要按半径进行比较，您需要更新它以比较 c1.weight 和 c2.weight。