C ++，排序一个向量基于另一个一C ++，排序一个向量基于另一个一(C++, Sort One V

我已经得到了最好的例子是，我想根据自己的分数排序的名称。

vector <string> Names {"Karl", "Martin", "Paul", "Jennie"};
vector <int> Score{45, 5, 14, 24};

所以，如果我排序的比分{5，14，24，45}，名称也应该根据自己的得分排序。

Answer 1:

在其他的答案已经建议：结合的名称和每个人的得分很可能是最简单的解决方案。

与相应的“解压”沿 - 两个向量组合到对一个矢量：一般地，这可以与有时被称为“拉链”操作来实现的。

一般实施，这可能如下所示：

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

// Fill the zipped vector with pairs consisting of the
// corresponding elements of a and b. (This assumes 
// that the vectors have equal length)
template <typename A, typename B>
void zip(
    const std::vector<A> &a, 
    const std::vector<B> &b, 
    std::vector<std::pair<A,B>> &zipped)
{
    for(size_t i=0; i<a.size(); ++i)
    {
        zipped.push_back(std::make_pair(a[i], b[i]));
    }
}

// Write the first and second element of the pairs in 
// the given zipped vector into a and b. (This assumes 
// that the vectors have equal length)
template <typename A, typename B>
void unzip(
    const std::vector<std::pair<A, B>> &zipped, 
    std::vector<A> &a, 
    std::vector<B> &b)
{
    for(size_t i=0; i<a.size(); i++)
    {
        a[i] = zipped[i].first;
        b[i] = zipped[i].second;
    }
}


int main(int argc, char* argv[])
{
    std::vector<std::string> names {"Karl", "Martin", "Paul", "Jennie"};
    std::vector<int> score {45, 5, 14, 24};

    // Zip the vectors together
    std::vector<std::pair<std::string,int>> zipped;
    zip(names, score, zipped);

    // Sort the vector of pairs
    std::sort(std::begin(zipped), std::end(zipped), 
        [&](const auto& a, const auto& b)
        {
            return a.second > b.second;
        });

    // Write the sorted pairs back to the original vectors
    unzip(zipped, names, score);

    for(size_t i=0; i<names.size(); i++)
    {
        std::cout << names[i] << " : " << score[i] << std::endl;
    }
    return 0;
}

Answer 2:

要做到这一点最好的办法是有与他们的得分组合名称的结构，并有一个载体。

struct Person
{
    std::string Name;
    int Score;
};

然后你就可以宣布你的载体：

std::vector<Person> people{ { "Karl", 45 }, { "Martin", 5 }, { "Paul", 14 } };

和排序，很容易与std::sort从<algorithm> ：

std::sort(people.begin(), people.end(), 
               [](const auto& i, const auto& j) { return i.Score < j.Score; } );

或者，如果你想在降序排序，你可以改变拉姆达：

std::sort(people.begin(), people.end(), 
               [](const auto& i, const auto& j) { return i.Score > j.Score; } );

Answer 3:

如果您无法将数据合并到对或结构的同时具有矢量，你可以创建迭代器的载体，或者从0到大小-1的索引。 然后，这个排序使用自定义比较。 最后，创建一个新的载体，使用迭代或索引填充它。

template<class T1, class A1, class T2, class A2>
std::vector<T1, A1> sort_by(
  std::vector<T1,A1> const& vin, std::vector<T2,A2> const& keys
){
  std::vector<std::size_t> is;
  is.reserve(vin.size());
  for (auto&& unused:keys)
    is.push_back(is.size());
  std::sort(begin(is),end(is),[&](std::size_t l, std::size_t r){
    return keys[l]<keys[r];
  });
  std::vector<T1, A1> r;
  r.reserve(vin.size());
  for(std::size_t i:is)
    r.push_back(vin[i]);
  return r;
}

Answer 4:

你可以这样做的一个方法是存储在一个单一的数据结构中的姓名和分数，如std::vector<std::pair<std::string,int>> ，然后排序，可以做如下：

#include <algorithm>
#include <vector>
#include <string>
#include <utility>
//...
std::vector<std::pair<std::string, int>> names_scores_vec;
// ... populate names_scores_vec...
// lambda for sorting, change to > for descending order
auto sort_by_scores = [](const std::pair<string,int>& _lhs, 
    const std::pair<string,int>& _rhs) { return _lhs.second < _rhs.second; };
std::sort(names_scores_vec.begin(), names_scores_vec.end(), sort_by_scores);

另外，使用存储如std::map或std::multimap ，如果你想重复键（即允许重复名称）。

Answer 5:

无法此通过自定义迭代器类型来完成？

编辑：

我在想什么的最简单形式 - 排序基于第一个一对向量的 - 是有一个迭代器，其功能，如提领，下标，成员访问，平等和排序比较称之为第一迭代器相应的功能，所有其他功能（复制，算术，交换，...​​），作用于两个迭代器。

template <typename Driver, typename Passenger>
struct duo_iterator { . . . };

template <typename D, typename P>
auto make_duo_iterator(D d, P p) -> duo_iterator<D, P> { . . . }

sort(make_duo_iterator(begin(v1), begin(v2)),
     make_duo_iterator(end(v1), end(v2)));

迭代器可以延长到multi_iterator任何重新排序算法的工作，指向任何数量的额外捎带序列。
这可能是一个有趣的小项目。 或者，也许类似的东西已经存在，在升压或其他地方。

EDIT2：

忘记以上。
埃里克Niebler的范围-V3库有一个view::zip包装，“考虑到N的范围，返回一个新的范围，其中m个元素是所有的第M个元素N的范围调用make_tuple的结果。”
排序范围内的元组的第一个元素的谓词可能只是做的伎俩。

Answer 6:

所以很多问我这个问题，没有人想出了一个满意的答复。 这里是一个std ::排序帮手，使两个矢量同时进行排序，考虑到仅一个向量的值。 该解决方案是基于自定义RadomIt（随机迭代），并直接作用于原始矢量数据，无需临时副本，结构重排的或附加的索引：

namespace std {

namespace sort_helper {

template <typename _Data, typename _Order>
struct value_reference_t;

template <typename _Data, typename _Order>
struct value_t {
    _Data data;
    _Order val;
    inline value_t(_Data _data, _Order _val) : data(_data), val(_val) {}
    inline value_t(const value_reference_t<_Data,_Order>& rhs);
};

template <typename _Data, typename _Order>
struct value_reference_t {
    _Data* pdata;
    _Order* pval;
    value_reference_t(_Data* _itData, _Order* _itVal) : pdata(_itData), pval(_itVal) {}
    inline value_reference_t& operator = (const value_reference_t& rhs) { *pdata = *rhs.pdata; *pval = *rhs.pval; return *this; }
    inline value_reference_t& operator = (const value_t<_Data,_Order>& rhs) { *pdata = rhs.data; *pval = rhs.val; return *this; }
    inline bool operator < (const value_reference_t& rhs) { return *pval < *rhs.pval; }
};

template <typename _Data, typename _Order>
struct value_iterator_t :
    iterator< random_access_iterator_tag, value_t<_Data,_Order>, ptrdiff_t, value_t<_Data,_Order>*, value_reference_t<_Data,_Order> >
{
    _Data* itData;
    _Order* itVal;
    value_iterator_t(_Data* _itData, _Order* _itVal) : itData(_itData), itVal(_itVal) {}
    inline ptrdiff_t operator - (const value_iterator_t& rhs) const { return itVal - rhs.itVal; }
    inline value_iterator_t operator + (ptrdiff_t off) const { return value_iterator_t(itData + off, itVal + off); }
    inline value_iterator_t operator - (ptrdiff_t off) const { return value_iterator_t(itData - off, itVal - off); }
    inline value_iterator_t& operator ++ () { ++itData; ++itVal; return *this; }
    inline value_iterator_t& operator -- () { --itData; --itVal; return *this; }
    inline value_iterator_t operator ++ (int) { return value_iterator_t(itData++, itVal++); }
    inline value_iterator_t operator -- (int) { return value_iterator_t(itData--, itVal--); }
    inline value_t<_Data,_Order> operator * () const { return value_t<_Data,_Order>(*itData, *itVal); }
    inline value_reference_t<_Data,_Order> operator * () { return value_reference_t<_Data,_Order>(itData, itVal); }
    inline bool operator  < (const value_iterator_t& rhs) const { return itVal  < rhs.itVal; }
    inline bool operator == (const value_iterator_t& rhs) const { return itVal == rhs.itVal; }
    inline bool operator != (const value_iterator_t& rhs) const { return itVal != rhs.itVal; }
};

template <typename _Data, typename _Order>
inline value_t<_Data,_Order>::value_t(const value_reference_t<_Data,_Order>& rhs)
    : data(*rhs.pdata), val(*rhs.pval) {}

template <typename _Data, typename _Order>
bool operator < (const value_t<_Data,_Order>& lhs, const value_reference_t<_Data,_Order>& rhs) {
    return lhs.val < *rhs.pval; }

template <typename _Data, typename _Order>
bool operator < (const value_reference_t<_Data,_Order>& lhs, const value_t<_Data,_Order>& rhs) {
    return *lhs.pval < rhs.val; }

template <typename _Data, typename _Order>
void swap(value_reference_t<_Data,_Order> lhs, value_reference_t<_Data,_Order> rhs) {
    std::swap(*lhs.pdata, *rhs.pdata);
    std::swap(*lhs.pval, *rhs.pval); }


} // namespace sort_helper

} // namespace std

这是既排序的姓名和年龄基于年龄值，采用标准的std ::排序的使用示例：

char* Names[] = { "Karl", "Paul", "Martin", "Jennie" };
int Age[] = { 45, 14, 5, 24 };
typedef std::sort_helper::value_iterator_t<char*,int> IndexIt;
std::sort(IndexIt(Names, Age), IndexIt(Names+4, Age+4));

分拣到：

{ "Martin", "Paul", "Jennie", "Karl" };
{ 5, 14, 24, 45 };

守则的Visual Studio 2017年和GCC 5.4.0测试。

文章来源: C++, Sort One Vector Based On Another One