Question

我正在使用索引向量对2个向量进行排序。

两个向量的大小不同。一个向量（键）的大小为X，另一个向量（描述符）的大小为X * 128（一个键由128个值参数化。）

为了创建索引向量，我生成了一个无符号向量，并使用iota函数将其放入了该向量[0,1,2，...，X] 然后我使用sort函数根据键的大小（keys [i] .s）对这些索引进行排序。

在那之后，我生成了另一个向量，在其中我使用索引的向量来复制描述符和键的值（分别称为descriptors_tmp和keys_tmp），然后我要使第一个键向量等于keys_tmp，与描述符相同，等于描述符_tmp。我的问题是：

-是否有一种方法可以在不进行任何复制的情况下进行复制。由于我不需要先前版本的键和描述符，因此我可以将矢量指向另一个矢量（例如* keys = * keys_tmp）？

-是否有更简单的方法来实现我要实现的目标？

我的代码：

void _siftMatch::getIdxOfSorting(std::vector<unsigned>& idx_scale_order)
{
    //keys[i].s is the scale and I sort depending decreasing scale
    auto cmp_scale = [this](int i, int j) {
        return keys[i].s > keys[j].s;
    };

    std::sort(idx_scale_order.begin(), idx_scale_order.end(), cmp_scale);
}   

void _siftMatch::sort() {
    //vector containing the index of sorted
    std::vector<unsigned>idx_scale_order;
    idx_scale_order.resize(keys.size());
    //Generate [0,1,...,X]
    std::iota(idx_scale_order.begin(), idx_scale_order.end(), 0); 

    //Sort the vector
    getIdxOfSorting(idx_scale_order); 

    std::vector<float> descriptors_tmp;
    std::vector<SiftGPU::SiftKeypoint> keys_tmp;

    for (int i = 0; i < idx_scale_order.size(); ++i) {
        keys_tmp.push_back(keys[idx_scale_order[i]]);
        for (int j = 0; j < 128; ++j)
            descriptors_tmp.push_back(descriptors[idx_scale_order[i] * 128 + j]);
     }
    //This is here that I want to put descriptors_tmp and keys_tmp in descriptors and keys
    //descriptors.swap(descriptors_tmp.data);
}

Answer 1

有没有一种方法可以做到这一点而无需复制

使用第4个生成的索引数组（根据3个数组之一进行排序）根据数组之一对3个数组进行排序的示例可能会有所帮助。关键部分是根据索引数组对所有4个数组进行就地重新排序。您需要针对您的情况进行修改。我不确定为什么要将索引数组转换为数字字符串数组（通过itoa调用），对于此答案中的示例，直接使用索引效果更好。

// sort 3 vectors according to one of them

#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;
}

用一个向量替换另一个向量的方法

1 个答案: