如何根据第一个向量的变化对双向量排序？

Question

我想实现类似DoubleVector的东西。 在该类中，我还想实现sort方法，该方法对v1_进行排序，并根据v1_的更改来更改v2_的顺序。 代码如下：

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
class DoubleVector
{
    vector<int> v1_;
    vector<char> v2_;
public:
    void sort()
    {
        //sort v1_ and also change order in v2_ according to changes in v1_
        std::sort(v1_.begin(), v1_.end() /*, lambda ?*/);
    }
    void add(int value_v1, char value_v2)
    {
        v1_.push_back(value_v1);
        v2_.push_back(value_v2);
    }
    void print()
    {
        const auto size = v1_.size();
        for (size_t i=0;i<size;++i)
        {
            cout << v1_[i] << " " << v2_[i] << endl;
        }
    }
};
int main()
{
    DoubleVector dv;
    dv.add(6, 'g');
    dv.add(2, 'r');
    dv.add(3, 'y');
    dv.add(4, 'a');
    cout << "Before sort:" << endl;
    dv.print();
    dv.sort();
    cout << "After sort:" << endl;
    dv.print();//the values in v2_ are in the same order they don't change order according to v1_ changes
    return 0;
}

如您所见，DoubleVector在排序之前包含：

6 g
2 r
3 y
4 a

排序后包含：

2 g
3 r
4 y
6 a

我想得到：

2 r
3 y
4 a
6 g

因此，第一个向量v1_已被排序，但是第二个向量v1_仍然具有相同的顺序，我想根据v1_的变化来更改第二个v2_向量中元素的顺序。 我可以编写它，但是我想以一种快速，干净的方式做到这一点，也许将lambda用作std :: sort函数中的第三个参数？ DoubleVector类中的向量v1_和v2_必须保持原样。

非常感谢你。

Answer 1

改成向量std::pair<int,char> 。 由于该对上的operator < first进行比较，然后决定second对的关系，因此对std::vector<std::pair<int,char>>排序将产生您想要的确切效果：

vector<pair<int,char>> v;
v.push_back(make_pair(6, 'g'));
v.push_back(make_pair(2, 'r'));
v.push_back(make_pair(3, 'y'));
v.push_back(make_pair(4, 'a'));
sort(v.begin(), v.end());
for (int i = 0 ; i != v.size() ; i++) {
    cout << v[i].first << " " << v[i].second << endl;
}

演示

Answer 2

您可以执行以下操作：

vector< pair<int,char> >v;
//do what you want
sort(v.begin(),v.end())

默认情况下，排序功能会根据第一个值进行排序，但您始终可以根据排序条件定义

• C ++ STL-STL sort（）的第三个参数如何工作？

Answer 3

尝试以下方法。

它的工作方式是仅根据int向量值对位置键对进行排序，然后使用此顺序提取值。

#include <iostream>
#include <algorithm>
#include <vector>

class dv
{
  std::vector<int> _v1;
  std::vector<char> _v2;
  std::vector<std::pair<int, int> > _order;

public:
  inline bool operator() (const std::pair<int, int>& v1_index_1, 
                          const std::pair<int, int>& v1_index_2) const {
    return _v1[v1_index_1.first] < _v1[v1_index_2.first]; 
  }

  void sort() {
    std::sort(_order.begin(), _order.end(), *this);
  }

  void add(int value_v1, char value_v2) {
    _order.push_back(std::pair<int, int>(_v1.size(), _v2.size()));
    _v1.push_back(value_v1);
    _v2.push_back(value_v2);
  }

  void print() {
    const auto size(_v1.size());
    for (size_t i=0; i<size; ++i) {      
      std::cout << _v1[_order[i].first] 
                << " " 
                << _v2[_order[i].second] 
                << std::endl;
    }
  }
};

int main() {

  dv dv;

  dv.add(6, 'g');
  dv.add(2, 'r');
  dv.add(3, 'y');
  dv.add(4, 'a');

  std::cout << "before sort: " << std::endl;

  dv.print();

  std::cout << "sorting: " << std::endl;

  dv.sort();

  std::cout << "after sort: " << std::endl;

  dv.print();

  return 0;
}