Question

我有一个三角形类，带有指向节点的指针（n0，n1，n2）。我还有一个方法在传递两个节点指针（a，b）时返回'other'节点。目前的实施是：

if ( n0 == a && n1 == b )
{
    return n2;
}
else if ( n0 == b && n1 == a )
{
    return n2;
}
else if ( n1 == a && n2 == b )
{
    return n0;
}
else if ( n1 == b && n2 == a )
{
    return n0;
}
else if ( n0 == a && n2 == b )
{
    return n1;
}
else if ( n0 == b && n2 == a )
{
    return n1;
}
else
{
    assert( 0 );
}
return NULL;

哪个有效，但可能不是最好的。在分析时，我的程序实际上在这个例程中花费了可测量的时间，因此值得花一些时间进行优化。但是，我不太熟悉编译器会做的优化，所以我不确定这是多余的。

节点没有特定的顺序，因此平均而言，它必须执行3.5次复合比较。

另一种方法是：

if ( n0 == a )
{
    if ( n1 == b )
    {
        return n2;
    }
    else if ( n2 == b )
    {
        return n1;
    }
    return NULL;
}
else if ( n1 == a )
{
    if ( n0 == b )
    {
        return n2;
    }
    else if ( n2 == b )
    {
        return n0;
    }
    return NULL;
}
else if ( n2 == a ) // Theoretically redundant.  Kept for safety.
{
    if ( n0 == b )
    {
        return n1;
    }
    else if ( n1 == b )
    {
        return n0;
    }
    return NULL;
}
return NULL;

平均比较为3.5的简单比较。这会更快 - 或者编译器会使它们变得相同吗？

有更快的方法吗？

我知道我可以消除多余的if。在第一种情况下，它将平均值降低到3.33复合比较。在第二种情况下，它将平均值降低到3.0简单比较。

我可以消除所有其他的，因为每个真正的代码块都包含一个返回。但是，我真的觉得编译器应该足够聪明，可以自己处理任何增益。

Answer 1

任何与自身混战的东西都是零，所以如果你给了三个中的两个，你可以通过n0 ^ n1 ^ n2 ^ a ^ b找到剩下的一个。它应该得到一个解释性的评论，但如果速度很重要，那几乎可以肯定是你最快的选择。

寻找其他节点的最快方法

1 个答案: