C++ std:：对c+中的2D向量进行排序+；_C++_Sorting_Stdvector

C++ std:：对c+中的2D向量进行排序+；

c++ sorting

C++ std:：对c+中的2D向量进行排序+；,c++,sorting,stdvector,C++,Sorting,Stdvector,我有一个2D向量InputVector定义如下： vector< vector<int> > InputVector(MAX_ITER, vector<int>(inN)); vector<int> CR(MAX_ITER); CR[i]是一个与InputVector[i]相关的属性（注意i可以从0到MAX\u ITER-1）。现在我想按CR的降序对InputVector进行排序，也就是说，如果CR[j]是所有CR中最高的，InputVecto

我有一个2D向量

InputVector

定义如下：

vector< vector<int> > InputVector(MAX_ITER, vector<int>(inN));

vector<int> CR(MAX_ITER);

CR[i]

是一个与

InputVector[i]

相关的属性（注意

可以从

到

MAX\u ITER-1

）。现在我想按

CR

的降序对

InputVector

进行排序，也就是说，如果

CR[j]

是所有

CR

中最高的，

InputVector[j]

应该是排序后的新

InputVector[0]

。

这可以使用

算法中定义的std:：sort
来完成吗？
这是一项非常奇怪的任务，但它是可以完成的
我会说-将CR[j]值推回InputVector[j]，然后编写一个自定义的“less”函数来比较最后的元素并将CR[j]值推回。诸如此类：
但似乎你真的应该重新考虑如何存储数据——你需要这样的逻辑是一个警告
#include <vector>
#include <algorithm>
#include <iostream>
#include <cassert>

using namespace std;

typedef vector<int> vi;
typedef vector<vi> vvi;

struct last_cmp
{
    bool operator()(const vi &lhs, const vi &rhs)
    {
        return lhs.back() > rhs.back();
    }
};

void weird_sort(vvi &InputVector, const vi &CR)
{
    assert(InputVector.size() == CR.size());

    for (size_t i = 0; i < InputVector.size(); i++)
        InputVector[i].push_back(CR[i]);

    sort(InputVector.begin(), InputVector.end(), last_cmp());

    for (size_t i = 0; i < InputVector.size(); i++)
        InputVector[i].pop_back();
}

int main()
{
    vvi InputVector;
    vi CR;

    InputVector.push_back(vector<int>(5, 0));
    InputVector.push_back(vector<int>(5, 1));
    InputVector.push_back(vector<int>(5, 2));
    InputVector.push_back(vector<int>(5, 3));
    InputVector.push_back(vector<int>(5, 4));

    CR.push_back(3);
    CR.push_back(2);
    CR.push_back(0);
    CR.push_back(1);
    CR.push_back(4);

    weird_sort(InputVector, CR);

    for (int i = 0; i < InputVector.size(); i++)
        cout << InputVector[i][0] << endl;
}

#包括
#包括
#包括
#包括
使用名称空间std；
typedef向量vi；
typedef向量vvi；
最后的结构
{
布尔运算符（）（常数vi和lhs、常数vi和rhs）
{
返回lhs.back（）>rhs.back（）；
}
};
无效排序（vvi和输入向量、常量vi和CR）
{
断言（InputVector.size（）==CR.size（））；
对于（size_t i=0；i您可以，但这会非常昂贵。您必须对InputVector
的每个成员在CR
上进行顺序搜索，以获得其相对排序值。这不是不可能的，但效率非常低
为了提高效率，请使用映射或哈希表。
我认为一个新类或使用pair会更好，但如果您真的想这样做的话
std::sort(InputVector.begin(), InputVector.end(), 
    [&CR,&InputVector](std::vector<int> &a, std::vector<int> &b){
        auto pos_a = &a - &(*InputVector.begin());
        auto pos_b = &b - &(*InputVector.begin());
        return (CR[pos_a] < CR[pos_b]);}
        );

排序（InputVector.begin（），InputVector.end（），
[&CR，&InputVector]（标准：：向量&a，标准：：向量&b）{
自动位置a=&a-&（*InputVector.begin（））；
自动位置b=&b-&（*InputVector.begin（））；
返回（CR[pos_a]

这在我做的小测试中是有效的，但我认为这可能是危险的。
在你的问题下的评论中，你澄清了你更喜欢将两个数组分开，而不是将它们组合在一起，并且你希望对CR
以及InputVector
进行排序。在这种情况下，最简单的方法是创建一个节奏将两个数组压缩为一个数组的rary数组，使用std:：sort
，然后解压缩回原来的两个数组
压缩和解压不应该太慢：它们是O（n），而排序是O（n log n）。此外，假设您的大部分数据包含在InputVector
中的嵌套vector
中，则可以使用vector:：swap
在临时数组中来回移动此数据，顾名思义，它围绕基础数据进行交换，而不是复制它
#include <vector>
using std::vector;
#include <algorithm>

void Sort(vector< vector<int> > &InputVector, vector<int>& CR) // assumes vectors the same size
{
    struct CRIntVec
    {
        int CR;
        vector<int> IntVec;
        bool operator<(const CRIntVec& rhs) const
        { return CR > rhs.CR; } // sort in descending order
    };
    vector<CRIntVec> combinedVec(InputVector.size());
    // Copy CR to combined vector but for efficiency swap in InputVector 
    for(int i=0; i<InputVector.size(); ++i) {
        combinedVec[i].CR = CR[i];
        combinedVec[i].IntVec.swap(InputVector[i]);
    }
    // Sort the combined vector
    std::sort(combinedVec.begin(), combinedVec.end());
    // Copy back from combined vector to CR, once again swapping for efficiency
    for(int i=0; i<InputVector.size(); ++i) {
        CR[i] = combinedVec[i].CR;
        combinedVec[i].IntVec.swap(InputVector[i]);
    }
}

#包括
使用std：：vector；
#包括
void Sort（vector&InputVector，vector&CR）//假定向量大小相同
{
结构CRIntVec
{
int-CR；
向量IntVec；
bool运算符rhs.CR；}//按降序排序
};
向量组合vec（InputVector.size（））；
//将CR复制到组合向量，但在InputVector中进行效率交换
对于（int i=0；i是否要同时对CR
进行排序？如果不这样做，则排序后InputVector
和CR
数组将不一致。更重要的是，您是否必须将此数据结构与两个单独的数组进行排序？更好的结构是vector
，其中第二个数组是成对中的元素是CR
属性。@TooTone完全同意。但我对处理如此复杂的结构感到不舒服。比如说，我必须将InputVector
传递给一个函数，然后传递InputVectorCR。首先是正确的吗？这里InputVectorCR
是vectorCR
进行排序吗？——因为如果你不想，那么InputVecto
r和CR
数组在排序后会不一致。如果我将InputVectorCR
作为vector
，然后调用sort（InputVectorCR.begin（）），InputVectorCR.end（））
它会被排序吗？我的意思是按升序排序。您仍然应该提供自定义的“less”函数，用于比较对的第一个元素。简单的调用排序（InputVectorCR.begin（），InputVectorCR.end（））不起作用。这是一个很好的答案，事实上比我的答案要好，因为你发现了一个非常好的黑客。但它不太正确，因为OP也想对CR
进行排序。你是说它可能会让一个进入…危险区？