比较三个数字的简单方法

我有一些代码，其中包含一系列if可以正常工作的，但是感觉很混乱。基本上，我想选择三个整数中最大的一个，并设置一个状态标志来说明选择了哪个。我当前的代码如下所示：

a = countAs();
b = countBs();
c = countCs();

if (a > b && a > c)
    status = MOSTLY_A;
else if (b > a && b > c)
    status = MOSTLY_B;
else if (c > a && c > b)
    status = MOSTLY_C;
else
    status = DONT_KNOW;

这种模式会发生几次，并且变量名较长，从视觉上确认每一个if都是正确的会有些困难。我觉得可能会有更好，更清晰的方法来执行此操作；有人可以建议什么吗？

有一些潜在的重复项，但它们与这个问题不太吻合。

在建议的副本中： 检查多个条件的方法？ 所有建议的解决方案似乎都与原始代码一样笨拙，因此无法提供更好的解决方案。

这篇文章优雅的处理if（if else）else的方法仅涉及嵌套级别和不对称性，这不是这里的问题。

分解逻辑，尽早返回

正如注释中所建议的那样，将逻辑简单地包装在函数中并用早退出就足够了，return以简化很多事情。另外，您可以通过将测试委派给另一个功能来分解一些功能。更具体地说：

bool mostly(max,u,v) {
   return max > u && max > v;
}

status_t strictly_max_3(a,b,c)
{
  if mostly(a,b,c) return MOSTLY_A;
  if mostly(b,a,c) return MOSTLY_B;
  if mostly(c,a,b) return MOSTLY_C;
  return DONT_KNOW;
}

这比我以前的尝试要短：

status_t index_of_max_3(a,b,c)
{
  if (a > b) {
    if (a == c)
      return DONT_KNOW;
    if (a > c)
      return MOSTLY_A;
    else
      return MOSTLY_C;
  } else {
    if (a == b)
      return DONT_KNOW;
    if (b > c)
      return MOSTLY_B;
    else
      return MOSTLY_C;
  }
}

上面的内容比较冗长，但是易于理解，恕我直言，并且不会多次重新计算比较。

视觉确认

在您的回答中，您说：

我的问题主要是视觉确认所有比较都使用相同的变量

...此外，在您的问题中，您说：

这种模式会发生几次，并且如果变量名较长，则在视觉上确认每个if是否正确都有些困难。

我可能无法理解您要实现的目标：是否要在需要的任何地方复制粘贴该模式？使用上述功能，您只需捕获一次模式a，b然后c根据需要检查一次所有比较使用的所有内容。这样，您在调用函数时就不必担心了。当然，也许在实践中，您的问题比您所描述的问题要复杂一些：如果是这样，请尽可能添加一些详细信息。

TL：DR; 您的代码已经正确并且“干净”。

我看到很多人都在四处寻找答案，但是每个人都在树林中迷失了森林。让我们做完整的计算机科学和数学分析以完全理解这个问题。

首先，我们注意到我们有3个变量，每个变量具有3个状态：<，=或>。排列总数为3 ^ 3 = 27个状态，我将为每个状态分配一个唯一的数字，表示为P＃。这个P＃数字是阶乘数系统。

列举所有的排列：

a ? b | a ? c | b ? c |P#| State
------+-------+-------+--+------------
a < b | a < c | b < c | 0| C
a = b | a < c | b < c | 1| C
a > b | a < c | b < c | 2| C
a < b | a = c | b < c | 3| impossible a<b b<a
a = b | a = c | b < c | 4| impossible a<a
a > b | a = c | b < c | 5| A=C > B
a < b | a > c | b < c | 6| impossible a<c a>c
a = b | a > c | b < c | 7| impossible a<c a>c
a > b | a > c | b < c | 8| A
a < b | a < c | b = c | 9| B=C > A
a = b | a < c | b = c |10| impossible a<a
a > b | a < c | b = c |11| impossible a<c a>c
a < b | a = c | b = c |12| impossible a<a
a = b | a = c | b = c |13| A=B=C
a > b | a = c | b = c |14| impossible a>a
a < b | a > c | b = c |15| impossible a<c a>c
a = b | a > c | b = c |16| impossible a>a
a > b | a > c | b = c |17| A
a < b | a < c | b > c |18| B
a = b | a < c | b > c |19| impossible b<c b>c
a > b | a < c | b > c |20| impossible a<c a>c
a < b | a = c | b > c |21| B
a = b | a = c | b > c |22| impossible a>a
a > b | a = c | b > c |23| impossible c>b b>c
a < b | a > c | b > c |24| B
a = b | a > c | b > c |25| A=B > C
a > b | a > c | b > c |26| A

通过检查，我们看到：

• 3个州，其中A是最大值，
• 3个州，其中B是最大值，
• 3个州，其中C是最大值，并且
• 4个州，其中A = B或B = C。

让我们编写一个程序（请参阅脚注）以使用A，B和C的值枚举所有这些排列。通过P＃进行稳定排序：

a ?? b | a ?? c | b ?? c |P#| State
1 <  2 | 1 <  3 | 2 <  3 | 0| C
1 == 1 | 1 <  2 | 1 <  2 | 1| C
1 == 1 | 1 <  3 | 1 <  3 | 1| C
2 == 2 | 2 <  3 | 2 <  3 | 1| C
2  > 1 | 2 <  3 | 1 <  3 | 2| C
2  > 1 | 2 == 2 | 1 <  2 | 5| ??
3  > 1 | 3 == 3 | 1 <  3 | 5| ??
3  > 2 | 3 == 3 | 2 <  3 | 5| ??
3  > 1 | 3  > 2 | 1 <  2 | 8| A
1 <  2 | 1 <  2 | 2 == 2 | 9| ??
1 <  3 | 1 <  3 | 3 == 3 | 9| ??
2 <  3 | 2 <  3 | 3 == 3 | 9| ??
1 == 1 | 1 == 1 | 1 == 1 |13| ??
2 == 2 | 2 == 2 | 2 == 2 |13| ??
3 == 3 | 3 == 3 | 3 == 3 |13| ??
2  > 1 | 2  > 1 | 1 == 1 |17| A
3  > 1 | 3  > 1 | 1 == 1 |17| A
3  > 2 | 3  > 2 | 2 == 2 |17| A
1 <  3 | 1 <  2 | 3  > 2 |18| B
1 <  2 | 1 == 1 | 2  > 1 |21| B
1 <  3 | 1 == 1 | 3  > 1 |21| B
2 <  3 | 2 == 2 | 3  > 2 |21| B
2 <  3 | 2  > 1 | 3  > 1 |24| B
2 == 2 | 2  > 1 | 2  > 1 |25| ??
3 == 3 | 3  > 1 | 3  > 1 |25| ??
3 == 3 | 3  > 2 | 3  > 2 |25| ??
3  > 2 | 3  > 1 | 2  > 1 |26| A

如果您想知道我如何知道哪些P＃状态是不可能的，那么现在您知道了。:-)

确定顺序的最小比较数为：

Log2（27）= Log（27）/ Log（2）=〜4.75 = 5个比较

即coredump给出了正确的5个最小比较数。我将他的代码格式化为：

status_t index_of_max_3(a,b,c)
{
    if (a > b) {
        if (a == c) return DONT_KNOW; // max a or c
        if (a >  c) return MOSTLY_A ;
        else        return MOSTLY_C ;
    } else {
        if (a == b) return DONT_KNOW; // max a or b
        if (b >  c) return MOSTLY_B ;
        else        return MOSTLY_C ;
    }
}

对于您的问题，我们不在乎是否进行相等性测试，因此我们可以省略2个测试。

如果得到错误的答案，代码有多干净/不好都没关系，因此这是您正确处理所有情况的好兆头！

接下来，为简单起见，人们一直试图“改善”答案，他们认为改善意味着“优化”比较次数，但严格来说，这并不是您要问的。您在询问“我觉得可能会有更好”的每个人面前感到困惑，但没有定义“更好”的含义。比较少？更少的代码？最佳比较？

现在，由于您询问的是代码的可读性（给定的正确性），因此我仅对代码进行一次更改以提高可读性：将第一个测试与其他测试对齐。

        if      (a > b && a > c)
            status = MOSTLY_A;
        else if (b > a && b > c)
            status = MOSTLY_B;
        else if (c > a && c > b)
            status = MOSTLY_C;
        else
            status = DONT_KNOW; // a=b or b=c, we don't care

我个人将以以下方式编写它，但这对于您的编码标准而言可能太过传统了：

        if      (a > b && a > c) status = MOSTLY_A ;
        else if (b > a && b > c) status = MOSTLY_B ;
        else if (c > a && c > b) status = MOSTLY_C ;
        else /*  a==b  || b ==c*/status = DONT_KNOW; // a=b or b=c, we don't care

脚注：这是生成排列的C ++代码：

#include <stdio.h>

char txt[]  = "< == > ";
enum cmp      { LESS, EQUAL, GREATER };
int  val[3] = { 1, 2, 3 };

enum state    { DONT_KNOW, MOSTLY_A, MOSTLY_B, MOSTLY_C };
char descr[]= "??A B C ";

cmp Compare( int x, int y ) {
    if( x < y ) return LESS;
    if( x > y ) return GREATER;
    /*  x==y */ return EQUAL;
}

int main() {
    int i, j, k;
    int a, b, c;

    printf( "a ?? b | a ?? c | b ?? c |P#| State\n" );
    for( i = 0; i < 3; i++ ) {
        a = val[ i ];
        for( j = 0; j < 3; j++ ) {
            b = val[ j ];
            for( k = 0; k < 3; k++ ) {
                c = val[ k ];

                int cmpAB = Compare( a, b );
                int cmpAC = Compare( a, c );
                int cmpBC = Compare( b, c );
                int n     = (cmpBC * 9) + (cmpAC * 3) + cmpAB; // Reconstruct unique P#

                printf( "%d %c%c %d | %d %c%c %d | %d %c%c %d |%2d| "
                    , a, txt[cmpAB*2+0], txt[cmpAB*2+1], b
                    , a, txt[cmpAC*2+0], txt[cmpAC*2+1], c
                    , b, txt[cmpBC*2+0], txt[cmpBC*2+1], c
                    , n
                );

                int status;
                if      (a > b && a > c) status = MOSTLY_A;
                else if (b > a && b > c) status = MOSTLY_B;
                else if (c > a && c > b) status = MOSTLY_C;
                else /*  a ==b || b== c*/status = DONT_KNOW; // a=b, or b=c

                printf( "%c%c\n", descr[status*2+0], descr[status*2+1] );
            }
        }
    }
    return 0;
}

编辑：根据反馈，将TL：DR移到顶部，删除了未排序的表，明确了27，清理了代码，描述了不可能的状态。

@msw告诉您使用数组而不是a，b，c，而@Basile告诉您将“ max”逻辑重构为函数。将这两个想法结合起来

val[0] = countAs();    // in the real code, one should probably define 
val[1] = countBs();    // some enum for the indexes 0,1,2 here
val[2] = countCs();

 int result[]={DONT_KNOW, MOSTLY_A, MOSTLY_B, MOSTLY_C};

然后提供一个计算任意数组的最大索引的函数：

// returns the index of the strict maximum, and -1 when the maximum is not strict
int FindStrictMaxIndex(int *values,int arraysize)
{
    int maxVal=INT_MIN;
    int maxIndex=-1;
    for(int i=0;i<arraysize;++i)
    {
       if(values[i]>maxVal)
       {
         maxVal=values[i];
         maxIndex=i;
       }
       else if (values[i]==maxVal)
       {
         maxIndex=-1;
       }
    }
    return maxIndex;
}

并称它为

 return result[FindStrictMaxIndex(val,3)+1];

LOC的总数似乎比原始LOC的总数有所增加，但是现在您已将核心逻辑包含在可重用的函数中，并且如果可以多次重用该函数，那么它就会开始得到回报。而且，该FindStrictMaxIndex功能不再与您的“业务需求”交织在一起（关注点分离），因此您以后不得不对其进行修改的风险比原始版本要低得多（开放-封闭原则）。例如，即使参数数量发生变化，该函数也不必更改，或者不需要使用MOSTLY_ABC以外的其他返回值，或者您正在处理a，b，c以外的其他变量。此外，使用数组代替3个不同的值a，b，c可能还会在其他地方简化代码。

当然，如果在您的整个程序中只有一个或两个地方可以调用此函数，并且您没有任何其他应用程序来将值保存在数组中，那么我可能会保留原始代码（或使用@coredump的改进）。

您可能应该使用宏或MAX 提供最多两个数字的函数。

然后，您只想要：

 status = MAX(a,MAX(b,c));

您可能已经定义

 #define MAX(X,Y) (((X)>(Y))?(X):(Y))

但在使用宏时要谨慎（尤其要注意副作用）（因为MAX(i++,j--) 行为会很奇怪）

所以最好定义一个函数

 static inline int max2ints(int x, int y) {
    return (x>y)?x:y;
 }

并使用它（或至少#define MAX(X,Y) max2ints((X),(Y))..）

如果您需要了解MAX的来源，则可以使用一个长宏，例如 #define COMPUTE_MAX_WITH_CAUSE(Status,Result,X,Y,Z) long do{... }while(0) 宏，也许

#define COMPUTE_MAX_WITH_CAUSE(Status,Result,X,Y,Z) do { \
  int x= (X), y= (Y), z=(Z); \
  if (x > y && y > z) \
    { Status = MOSTLY_FIRST; Result = x; } \
  else if (y > x && y > z) \
    { Status = MOSTLY_SECOND; Result = y; } \
  else if (z > x && z > y) \
    { Status = MOSTLY_THIRD; Result = z; } \
  /* etc */ \
  else { Status = UNKNOWN; Result = ... } \
} while(0)

然后，您可以COMPUTE_MAX_WITH_CAUSE(status,res,a,b,c) 在几个地方调用。这有点丑陋。我定义的局部变量x，y，z 降低不良副作用....

我对此进行了更多的思考，因此由于我的问题主要是视觉确认所有比较均使用相同的变量，因此我认为这可能是一种有用的方法：

a = countAs();
b = countBs();
c = countCs();

if (FIRST_IS_LARGEST(a, b, c))
    status = MOSTLY_A;
else if (SECOND_IS_LARGEST(a, b, c))
    status = MOSTLY_B;
else if (THIRD_IS_LARGEST(a, b, c))
    status = MOSTLY_C;
else
    status = DONT_KNOW; /* NO_SINGLE_LARGEST is a better name? */

每个宏都采用a，b并且c以相同的顺序进行确认很容易，而且宏名称使我省去了所有比较和操作的工作。