C++ 有没有标准的算法来对向量元素进行两两比较？

我基本上有两个无序元素的向量，可以检查它们是否相等。有没有像std:：equal这样的标准算法来比较所有n^2对并检查一个向量的所有元素是否都位于另一个向量中？

向量有多大？比如：

template <typename T>
bool
unorderedEqual( std::vector<T> const& v1, std::vector<T> const& v2 )
{
    return v1.size() == v2.size()
        && std::find_if(
            v1.begin(), v1.end(),
            [&v2]( T const& elem ) { 
                return std::find( v2.begin(), v2.end(), elem ) == v2.end();
            } ) == v1.end();
}

模板
布尔
无序相等（标准：：向量常量和v1，标准：：向量常量和v2）
{
返回v1.size（）==v2.size（）
&&std：：查找\u if(
v1.begin（），v1.end（），
[&v2]（T常量和元素）{
返回std:：find（v2.begin（），v2.end（），elem）==v2.end（）；
}）==v1.end（）；
}

可能会成功，但它是O（n^2）（这意味着它只是好的 对于非常小的向量），如果向量 包含重复的元素。（还要注意，我还没有测试过它， 所以它可能包含打字错误和其他错误，但它应该 尽量靠近，给出大致的想法。）

否则，我想你得分类；即使物体 不要支持少于，您应该能够定义 排序函数。（该命令可以是任意的，没有

---

重要意义，但允许使用

std:：sort

）

假设向量包含数据，复制或交换数据成本较高：

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

typedef std::vector<std::size_t> Index;
typedef std::vector<int> Data;
inline void init(Index& index, const Data& data) {

    struct Less
    {
        const Data& data;

        Less(const Data& data)
        :   data(data)
        {}

        bool operator () (std::size_t a, std::size_t b) {
            return data[a] < data[b];
        }
    };

    index.reserve(data.size());
    for(size_t i = 0; i < data.size(); ++i) {
        index.push_back(i);
    }
    Less less(data);
    std::sort(index.begin(), index.end(), less);
}

int main(){

    Data d0 { 1, 0, 4, 2, 5, 3 };
    Data d1 { 5, 2, 3, 0, 4, 1 };

    if(d0.size() == d1.size()) {
        Index i0;
        Index i1;
        init(i0, d0);
        init(i1, d1);
        for(std::size_t i = 0; i < d0.size(); ++i) {
            std::cout << d0[i0[i]] << " == " << d1[i1[i]] << std::endl;
            if(d0[i0[i]] != d1[i1[i]]) {
                std::cout << "Not equal" << std::endl;
                return 1;
            }
        }
    }
    std::cout << "Equal" << std::endl;
    return 0;
}

#包括
#包括
#包括
#包括
向量索引；
typedef std：：矢量数据；
内联void init（索引和索引、常量数据和数据）{
无结构
{
常量数据和数据；
减去（常数数据和数据）
：数据（数据）
{}
布尔运算符（）（std:：size\u t a，std:：size\u t b）{
返回数据[a]<数据[b]；
}
};
index.reserve（data.size（））；
对于（size_t i=0；istd:：cout对于较大的向量，最便宜的方法是对两者进行排序，然后测试是否相等

#include <vector>
#include <algorithm>

// ....

vector<yourType> v1;
vector<yourType> v2;

sort(v1);
sort(v2);
bool result = equal(begin(v1), end(v1), begin(v2));

#包括
#包括
// ....
向量v1；
矢量v2；
排序（v1）；
排序（v2）；
布尔结果=相等（开始（v1）、结束（v1）、开始（v2））；
按O（nlogn）排序并按O（n）比较？这可能是
std:：unordered_set
@DyP:只能检查相等性的无序元素的作业，听起来不可能排序。@Jon可能是这样。我不会想到无序容器支持
=
和
！=
，但显然它们支持。最糟糕的情况复杂性是O（n^2）（这就是我不希望它得到支持的原因），但在大多数情况下，你可能不会遇到最坏的情况。@DavidRodríguez dribeas，听起来是这样。另一方面，我认为我从未见过一种数据类型，它不可能定义某种任意排序，而这种排序足以进行
排序
（即使它不符合任何逻辑顺序）。对于重复项，我想您应该使用
std:：count
？但是，实际上不使用边数据结构（如
std:：unordered_map
来统计每个元素的出现次数）似乎很麻烦。