Question

我正在开发一个C ++应用程序。

我有2个点矢量

vector<Point2f> vectorAll;
vector<Point2f> vectorSpecial;

Point2f定义为typedef Point_<float> Point2f;

vectorAll有1000点，而vectorSpecial有10点。

第一步：

我需要根据vectorAll中的顺序对vectorSpecial中的点进行排序。所以像这样：

For each Point in vectorSpecial
    Get The Order Of that point in the vectorAll
    Insert it in the correct order in a new vector

我可以进行双循环并保存索引。然后根据索引对点进行排序。然而，当我们有很多点时，这个方法花费的时间太长（例如vectorAll中的10000个点和vectorSpecial中的1000个点，这样就可以进行一千万次迭代）

有哪些更好的方法呢？

第二步：

vectorApecial中的某些点可能无法在vectorAll中使用。我需要取最接近它的点（通过使用通常的距离公式sqrt((x1-x2)^2 + (y1-y2)^2)）

这也可以在循环时完成，但如果有人对更好的方法有任何建议，我将不胜感激。

非常感谢您的帮助

Answer 1

您可以std::sort使用vectorAll Compare设置vectorSpecial功能，以考虑struct myCompareStruct { std::vector<Point2f> all; std::vector<Point2f> special; myCompareStruct(const std::vector<Point2f>& a, const std::vector<Point2f>& s) : all(a), special(s) { } bool operator() (const Point2f& i, const Point2f& j) { //whatever the logic is } }; std::vector<Point2f> all; std::vector<Point2f> special; //fill your vectors myCompareStruct compareObject(all,special); std::sort(special.begin(),special.end(),compareObject);的内容：

{{1}}

Answer 2

对于第一步，您可以使用C ++ 11 lambda效果很好（special.size（）= K，all.size（）= N）

#include <algorithm>   // std::sort, std::transform, std::find, std::min_element
#include <iterator>    // std::distance

std::vector<int> indices;
indices.reserve(special.size());

// locate exact index in all for every element of special. Complexity = O(K * N)
std::transform(special.begin(), special.end(), indices.begin(), [&all](Point2f const& s){                   
     return std::distance(
         all.begin(), 
         std::find(all.begin(), all.end(), s)
     ); 
});

// sort special based on index comparison. Complexity = O(K * log(K))
std::sort(special.begin(), special.end(), [&indices](Point2f const& r, Point2f const& s){
     auto i = std::distance(special.begin(), r);
     auto j = std::distance(special.begin(), s);
     return indices[i] < indices[j];
});

解释：首先，对于special中的每个点，计算all的开头与all中特殊元素的位置之间的距离，并将结果存储到indices向量中。其次，通过比较special向量中每对元素对应的元素，对indices的所有元素进行排序。

对于第二步，您只需更改计算索引的方式

// locate closest element in all for every element of special. Complexity = O(K * N)
std::transform(special.begin(), special.end(), indices.begin(), [&all](Point2f const& s){                   
     return std::distance(
         all.begin(), 
         std::min_element(all.begin(), all.end(), [&s](Point2f const& a){
              return // Euclidean 2D-distance between a and s    
         });
     ); 
});

解释：与您的第一步相比，唯一的变化是，对于special中的每个元素，您都会在all中找到与其最接近的元素，您可以通过计算问题中建议的最小欧几里德距离。

UPDATE ：您可以先将all的每个元素的索引存储到std::unordered_map哈希表中，然后再进行比较，从而进行空格/时间权衡。基于查找该哈希表的special元素。这将第一步的时间复杂度降低到O（N）（假设K

根据另一个向量排序点向量

2 个答案: