Question

一个类包含两个整数;这个类有两个实例。我想比较它们以确保两个实例包含相同的两个数字（它们的顺序无关紧要）。

我可以这样做：

bool operator==(const Edge &e, const Edge &f) {
    return ((e.p1 == f.p1) || (e.p1 == f.p2)) && ((e.p2 == f.p1) || (e.p2 == f.p2));
}

这是最好的方式吗？会有很多这样的比较，所以我想确保我做出最有效的选择。顺便说一句，运营商将主要由std::unordered_set类使用 - 以防这个信息很重要。

Answer 1

我认为你的逻辑有点混淆......如果我理解正确，给定对（a，b）和（x，y），你要检查（a，b）== s（x ，y），对于某些排列s？

bool operator==(const Edge &e, const Edge &f) {
    return ((e.p1 == f.p1) && (e.p2 == f.p2)) ||
           ((e.p2 == f.p1) && (e.p1 == f.p2));
}

至于表现......这里没有什么可以优化的。如果您的程序很慢，请去其他地方。

Answer 2

这可能不是最快的，它需要C ++ 11。但它很好而且简短：

bool operator==(const Edge& e, const Edge& f) {
  return std::minmax(e.p1, e.p2) == std::minmax(f.p1, f.p2);
}

它还建议进行优化（我通常会使用）：按顺序保留p1和p2，这样每次都不需要调用minmax。然后你有一个最佳的解决方案。

Answer 3

这对两个人都有效。然而，对于更多，它显然非常快速变得非常丑陋。实际上，如果您以“天真”的方式执行此操作，则需要进行n!比较以检查何时有n个变量。

更简单的方法如下：

static constexpr Edge::number()
{
    return <number_of_values>;
}

bool operator==(const Edge& e, const Edge& f)
{
    constexpr size = Edge::number();
    std::array<int, size> earr = {{e.p1, e.p2, ..., e.pn}};
    std::array<int, size> farr = {{f.p1, f.p2, ..., f.pn}};
    return std::is_permutation(earr.begin(), earr.end(), farr.begin());
}

如果它总是两个，你可以简单地写成：

bool operator==(const Edge& e, const Edge& f)
{
    std::array<int, 2> earr = {{e.p1, e.p2};
    std::array<int, 2> farr = {{f.p1, f.p2}};
    return std::is_permutation(earr.begin(), earr.end(), farr.begin());
}

测试无序等式与测试一个序列是否是另一个序列的排列相同。

编辑：对于我来说应该是显而易见的，可以通过检查排序的序列是否相等来测试。将std::is_permutation替换为上面的std::sort和std::equal，O(n log n)代替O(n^2)。

Answer 4

根据我对您的问题的理解，我建议您遵循以下解决方案：

只需在课堂上添加功能，如下所示：

bool isExist(int point)
{
  if(this.p1==point || this.p2==point)
    return true;
  else
   return false;
}

您可以通过调用此函数来应用逻辑。

如果我错了，请纠正我......

比较两对整数的最有效方法

4 个答案: