C++ 双矢量排序

我想知道，如果你有一个

向量

和一个

向量

及其对应的对，是否有可能在保持对匹配的同时按字母顺序对

向量

进行排序

我知道这可以通过创建一个包含两个值的类并对其进行排序来实现，但我宁愿保留两个单独的向量

有什么想法吗

最终代码：

#include "std_lib_facilities.h"

struct Name_pairs
{
       vector<string>names;
       vector<double>ages;
       void quicksort(vector<string>& num, vector<double>& num2, int top, int bottom);
       int divide(vector<string>& array, vector<double>& array2, int top, int bottom);
       bool test();
       string read_names();
       double read_ages();
       void print();
};

string Name_pairs::read_names()
{
       string name;
     cout << "Enter name: ";
     cin >> name;
     names.push_back(name);
     return name;
}

double Name_pairs::read_ages()
{
     double age;
     cout << "Enter corresponding age: ";
     cin >> age;
     ages.push_back(age);
     cout << endl;
     return age;
}

int Name_pairs::divide(vector<string>& array, vector<double>& array2, int top, int bottom)
{
    string x = array[top];
    int i = top-1;
    int j = bottom+1;
    string temp;
    double temp2;
    do{
        do
        {
             j--;
             }while(x<array[j]);

        do
        {
             i++;
             }while(x>array[i]);

        if(i<j)
        {
               temp = array[i];
               temp2 = array2[i];
               array[i] = array[j];
               array2[i] = array2[j];
               array[j] = temp;
               array2[j] = temp2;
               }
               }while(i<j);
        return j;
}


void Name_pairs::quicksort(vector<string>& num, vector<double>& num2, int top, int bottom) // top is subscript of beginning of vector
{
     int middle;
     if(top < bottom)
     {
            middle = divide(num, num2, top, bottom);
            quicksort(num, num2, top, middle);
            quicksort(num, num2, middle+1, bottom);
            }
     return;
}

void Name_pairs::print()
{
     for(int i = 0; i < (names.size()-1) && i < (ages.size()-1); ++i)
             cout << names[i] << " , " << ages[i] << endl;
}

int main(){
    Name_pairs np;
    cout << "Enter names and ages. Use 0 to cancel.\n";
    bool finished = false;
    while(!finished){
    finished = "0" == np.read_names();
    finished = 0 == np.read_ages();}
    np.quicksort(np.names, np.ages, 0, (np.names.size()-2));
    np.print();
    keep_window_open();}

#包括“std_lib_facilities.h”
结构名称\u对
{
矢量名称；
矢量；
无效快速排序（向量和数值、向量和数值2、整数顶部、整数底部）；
整数除法（向量和数组、向量和数组2、整数顶部、整数底部）；
布尔检验（）；
字符串read_names（）；
双读本（）；
作废打印（）；
};
字符串名称\u对：：读取\u名称（）
{
字符串名；
姓名；
名称。推回（名称）；
返回名称；
}
双名双对：：read_ages（）
{
双倍年龄；
年龄；
年龄。推回（年龄）；
cout如果您打算使用std:：sort，则需要使用类似pair的数据结构。
当然，您可以手动对向量进行排序，并基本上重新实现std:：sort

这个问题实际上取决于大量其他问题，例如：


向量中有多少项
性能有多重要
你真的想实现你自己的排序算法吗

实现快速排序应该是相当轻松的，并且可以避免移动数据。
如果您自己手动对它们进行排序，您可以只交换双数组中的相应项以及通常会执行的字符串数组中的项。或者，您可以使用第三个数组：

vector<unsigned int> indices;

向量索引；

只需索引到字符串/双精度数组中，并对该数组进行排序（根据字符串数组中的值进行交换）。
您可以创建一个辅助向量：

vector<unsigned int> indices;

向量索引；

将其初始化为
0,1,2，…n-1
，其中
n
是向量的大小，并让
排序算法使用查看
向量的函子对其进行排序，即，当要求比较index1和index2时，函子将查找相应的字符串并进行比较。一旦执行
索引
sorted，您可以轻松地对两个数组进行排序，使其在线性时间内与之一致

编辑：我没有看到Jim Buck的第二个建议。我的答案只是这个建议的一个扩展版本。
虽然索引的概念实际上是相同的，但实际上您可以定义一个知道这两个向量的随机访问迭代器类型，并移动它们（通过赋值）在同步中。迭代器的值类型应该是pair。在函数式编程中，您可以将其称为“zip”（但不是zipper）

除非你的空间很紧，否则这绝对不值得麻烦。如果你有空间，实际上将两个向量压缩成一个向量对，或者使用索引方法，两者都更容易

如果你能在第一次就把它做好，复制/粘贴一个10行的快速排序，并进行明显的修改，这将是实现你想要的最快的方法


Ed的注释：Boost中已经有一个书面版本可用，正如这个对同一个问题的新答案所指出的：
您使用两个向量而不是更复杂的数据结构有什么特别的原因吗？从书中学习，这是练习的目的。甚至还没有了解地图或数组。嗯。那么呢我如何同步向量，使一个的索引发生的任何事情都会发生在另一个的索引上。问题是同步.std:：sort不允许它，所以你必须实现你自己的排序。嗯……我在中查看了排序成员，看起来我无法从中借用任何东西。有什么想法吗？如果你真的要做到这一点，实现一个快速排序，或者，如果性能不是问题，实现一个泡泡排序，使两个向量保持同步。好的，谢谢，听起来像一个有趣的小项目（我希望！）.不，我没有单独对每个对象进行排序。这可能有太多的数据。不过，我对你的第二个想法很感兴趣，但是它怎么能同时对字符串和双精度进行索引呢？我不是必须为此创建一个类吗？不-索引只是一个数字。这个想法非常可行。你创建一个向量索引，然后将自定义排序传递给std:：sort，它比较myDoubles[Indexs[i]]而不是索引[i]。然后，您将得到索引[i]的排序，以便myDoubles[Indexs[i]