用两个向量排序

Question

我想知道是否有可能，例如，如果您有一个 vector<string> 和一个 vector<double> 以及相应的配对，则可以按字母顺序对 vector<string> 进行排序，同时保持配对匹配。

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

有什么想法吗？

最终代码：

#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();}

Answer 1

如果您自己手动对它们进行排序，您只需将双精度数组中的相应项目与您通常会做的字符串数组中的项目一起交换即可。或者，你可以有第三个数组：

vector<unsigned int> indices;

这只是对字符串/双精度数组的索引，然后对该数组进行排序（根据字符串数组中的值进行交换）。

Answer 2

你可以创建一个辅助向量：

vector<unsigned int> indices;

将其初始化为0,1,2,...n-1，其中n 是向量的大小，并让sort 算法使用查看vector<string> 的函子对其进行排序，即，当被要求比较index1 和index2，仿函数将查找相应的字符串并进行比较。对 indices 进行排序后，您可以轻松地对两个数组进行排序以在线性时间内符合它。

编辑：我没有看到 Jim Buck 的第二个建议。我的回答只是一个扩展版本。

Answer 3

虽然索引的想法实际上是相同的，但实际上您可以定义一个知道两个向量的随机访问迭代器类型，并同步移动它们（通过赋值）。该迭代器的 value_type 将是 pair。在函数式编程中，您可以将其称为“拉链”（但不是拉链）。

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

如果您能在第一时间做对，复制/粘贴一个 10 行的快速排序并进行明显的修改将是您想要的最快的方法。

---

Ed 的说明： Boost 中有一个已经编写好的 Zip Iterator，正如对同一问题的更新答案中所指出的那样："Locking" two vectors and sorting them

Answer 4

如果您打算使用 std::sort，则需要使用像对这样的数据结构。 当然，您可以手动对向量进行排序，并从本质上重新实现 std::sort。

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

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

实施快速排序应该相当轻松，并且可以避免移动数据。