“锁定”两个向量并对它们进行排序

Question

I have this two vector<double> 's mass and velocity both of the same size N . They contain the information about the mass and velocity of N particles. mass[i] and velocity[i] are thus properties of the i'th particle

Is it possible in C++ to "lock" these two vectors together and sort them in increasing order of mass? Thus after the sorting the vector mass should be in increasing order, and the velocity vector should contain the corresponding velocities of the sorted masses

eg Before sorting mass = (4,2,1,3) and velocity = (13, 14,15,16 ) After sorting mass=(1,2,3,4) and velocity =(15, 14, 16, 13)

The one (non-efficient) way I know for this is to transfer the data into an vector of struct's

struct particle
{

double mass;
double velocity;


bool operator < (const particle& str) const

 {
    return (mass < str.mass);
  }



};

and create vector<particle> particlelist(N) and then sort this vector by using the std::sort by overloading the < operator as I have done in the definition above.

I do not want to put my data into Array of Structures fashion since I have heard it is inefficient compared to the Structure of Arrays approach(at least in CUDA).

Answer 1

Create vector indexes; fill it by values 0..n-1 than

    struct CmpMass {
    {
       CmpMass(vector<double>& vec) : values(vec){}
       bool operator() (const int& a, const int& b) const
       {
           return values[a] < values[b];
       }
       vector<double>& values;
    }

sort(indexes.begin(), indexes.end(), CmpMass(mass));

than you have in vector indexes order of items in both arrays. Than you can create mass/velocity vectors in correct order or convert index during access: mass[indexes[i]], velocity[indexes[i]]

Answer 2

At least as far as I know, none of the sorting algorithms built into the standard library will do this for you directly. The most obvious possibility would probably be to use a Boost Zip Iterator to make the two arrays act like a single collection.

Answer 3

Why don't you use std::pair as you have two values which are linked, you than can then implement your own comparison method/function to pass on to the std::sort function via pointer(there exist an overloaded version of std::sort which supports that).

But be sure that you have a strict weak ordering implemented, because else std::sort might lead to a SEGFAULT