C++ 比较对象的3个数字属性

我想知道什么是比较一个数字的三个数值性质并确定最低值和最高值的最快和最有效的方法。 假设我有一个具有以下属性的对象

obj.a = 5;
obj.b = 13;
obj.c = 2;

现在我需要计算最低值（2）和最高值（13）

---

我的一个选择是使用条件语句，因此有三个条件用于检查最大元素，三个条件用于检查最低元素。结果是6个条件语句。我的另一个选择是将这些值推送到向量中，然后从排序向量中检索极值。有没有其他办法？有什么建议吗

不超过三个选项的解决方案：

struct Obj
{
    int a;
    int b;
    int c;
    std::pair<int,int> getMinMax() const
    {
        std::pair<int,int> minmax = a< b ? std::make_pair(a,b) : std::make_pair(b,a);
        if (c < minmax.first )
            minmax.first = c;
        else if (c > minmax.second)
            minmax.second = c;
        return minmax;
    }
};

结构对象 { INTA； int b； INTC； std:：pair getMinMax（）常量 { std:：pair minmax=a最小最大秒） 最小最大秒=c； 返回最小最大值； } };

---

不超过三个选项的解决方案：

struct Obj
{
    int a;
    int b;
    int c;
    std::pair<int,int> getMinMax() const
    {
        std::pair<int,int> minmax = a< b ? std::make_pair(a,b) : std::make_pair(b,a);
        if (c < minmax.first )
            minmax.first = c;
        else if (c > minmax.second)
            minmax.second = c;
        return minmax;
    }
};

结构对象 { INTA； int b； INTC； std:：pair getMinMax（）常量 { std:：pair minmax=a最小最大秒） 最小最大秒=c； 返回最小最大值； } }; 为两个变量创建Min（）函数，如下所示：

int Min(int x, int y)
{
    return y ^ ((x ^ y) & -(x < y));
}

int Max(int x, int y)
{
    return x ^ ((x ^ y) & -(x < y));
}

int max = Max(a,Max(b,c));
int min = Min(a,Min(b,c));

这些方法非常有效，可用于任何数量的变量比较

它使用的概念是

一个数与其自身的异或为0

带0的数字的XOR是数字本身

同样，这可以用于N个数字比较的嵌套调用

注意：您甚至可以替换

x>31

（考虑x是32位有符号整数）

我非常确信，对于3个数字来说，它的效率再高不过了，为2个变量创建Min（）函数，如下所示：

int Min(int x, int y)
{
    return y ^ ((x ^ y) & -(x < y));
}

int Max(int x, int y)
{
    return x ^ ((x ^ y) & -(x < y));
}

int max = Max(a,Max(b,c));
int min = Min(a,Min(b,c));

这些方法非常有效，可用于任何数量的变量比较

它使用的概念是

一个数与其自身的异或为0

带0的数字的XOR是数字本身

同样，这可以用于N个数字比较的嵌套调用

注意：您甚至可以替换

x>31

（考虑x是32位有符号整数）

---

我非常确信，对于3个数字，它的效率再高不过了

我给出了psudocode：

a[0] = obj.a
a[1] = obj.b
a[2] = obj.c

要获得最大值，请执行以下操作：

index = int(obj.a < obj.b)
larger = a[index]

largest = a[(larger > obj.c) ? index : 2]

index=int（对象a<对象b）
较大=a[索引]
最大=a[（较大>对象c）？索引：2]

要获得最小值，请执行以下操作：

index = int (obj.a > obj.b)
smaller = a[index]

smallest = a[(smaller < obj.c) ? index : 2]

index=int（对象a>对象b）
更小=a[索引]
最小值=a[（较小的

---

进行2+2比较。

我给出了psudocode：

a[0] = obj.a
a[1] = obj.b
a[2] = obj.c

要获得最大值，请执行以下操作：

index = int(obj.a < obj.b)
larger = a[index]

largest = a[(larger > obj.c) ? index : 2]

index=int（对象a<对象b）
较大=a[索引]
最大=a[（较大>对象c）？索引：2]

要获得最小值，请执行以下操作：

index = int (obj.a > obj.b)
smaller = a[index]

smallest = a[(smaller < obj.c) ? index : 2]

index=int（对象a>对象b）
更小=a[索引]
最小值=a[（较小的

---

进行2+2比较。

如果可以使用C+11，您可以执行以下操作：

auto result = std::minmax({a, b, c});

---

result。第一个

将保存最小的值，

result。第二个

将保存最大的值-这是一个。

如果可以使用C+11，您可以执行以下操作：

auto result = std::minmax({a, b, c});

---

<代码>结果。第一次/代码>将保持最小值，<代码>结果。第二次/代码>最大-这里是a。

一旦发现A是最小值，就不必再考虑最大值了。因此，任何分别确定最小值和最大值的解都是次优解

有6种订购方式：abc acb bac bca cab cba。因此，任何解决方案都不能使用少于6个分支

此解决方案有6个分支，每个案例最多有3个比较，因此我希望它是最佳的：

if (obj.a < obj.b)
{
  if (obj.b < obj.c)
  {
     min = obj.a; max = obj.c;  // abc
  }
  else if (obj.c < obj.a)
  {
     min = obj.c; max = obj.b;  // cab
  }
  else
  {
     min = obj.a; max = obj.b;  // acb
  }
}
else
{
  if (obj.a < obj.c)
  {
     min = obj.b; max = obj.c;  // bac
  }
  else if (obj.c < obj.b)
  {
     min = obj.c; max = obj.a;  // cba
  }
  else
  {
     min = obj.b; max = obj.a;  // bca
  }
}

---

底线：谁会想到“天真”的方法会比把它全部写出来更快 有6种订购方式：abc acb bac bca cab cba。因此，任何解决方案都不能使用少于6个分支

此解决方案有6个分支，每个案例最多有3个比较，因此我希望它是最佳的：

if (obj.a < obj.b)
{
  if (obj.b < obj.c)
  {
     min = obj.a; max = obj.c;  // abc
  }
  else if (obj.c < obj.a)
  {
     min = obj.c; max = obj.b;  // cab
  }
  else
  {
     min = obj.a; max = obj.b;  // acb
  }
}
else
{
  if (obj.a < obj.c)
  {
     min = obj.b; max = obj.c;  // bac
  }
  else if (obj.c < obj.b)
  {
     min = obj.c; max = obj.a;  // cba
  }
  else
  {
     min = obj.b; max = obj.a;  // bca
  }
}

---

---

底线：谁会想到“天真”的方法会比把它全部写出来更快

可能的数字有一个范围吗？创建并排序一个向量绝对不是比较3个数字的最有效的方法。极端的方法，但应该适用于大范围的数字：二元搜索树我认为填充一个向量将是过分的。想要其他意见吗？可能的数字有一个范围吗？创建并排序一个向量绝对不是比较3个数字的最有效的方法。极端的方法，但应该适用于大范围的数字：二进制搜索树我认为填充一个向量会有点过头。想要其他意见的副本，但你知道，这将只适用于1和0之间的整数？（xtrue或

false

，该值被提升为

int

，导致

1

或

0

。1以二进制形式表示为

…000001

，因此将其与

&

一起应用于另一个数字将只保留该另一个数字的最后一位。因此

5+（（10-5）和（10-5））

=

5+（5&1）

=

5+1

=

6

，这显然是不正确的。@Azzu oh我忘记了负号。谢谢您指出。现在您只需要在

max（）

@Azzu（）中将

操作符更改为code>，这很好。在分析之后，这个答案是