C++ 找到三个整数中最大整数的最有效方法

下面是我的伪代码

功能最高（i、j、k）
{
如果（i>j&&i>k）
{
返回i；
}
else如果（j>k）
{
返回j；
}
其他的
{
返回k；
}
}

---

我认为这是可行的，但C++中最有效的方法是

找到你需要的最大值来精确地查看3个int，不多不少。你看到的是6对3的比较。你应该能在第三和第二次比较中做到这一点

int ret = max(i,j);
ret = max(ret, k);
return ret;

伪代码：

result = i
if j > result:
  result = j
if k > result:
  result = k
return result

怎么样

return i > j? (i > k? i: k): (j > k? j: k);

两次比较，不使用瞬态临时堆栈变量…

您当前的方法： （0.40秒）

克里斯的解决方案：

int ret = max(i,j);
ret = max(ret, k);
return ret;

result = i;
if (j > result)
  result = j;
if (k > result)
  result = k;
return result;

（0.39秒）

伊格纳西奥·巴斯克斯·艾布拉姆斯的解决方案：

result = i;
if (j > result)
  result = j;
if (k > result)
  result = k;
return result;

（0.40秒）

查尔斯·布雷塔纳的：

return i > j? (i > k? i: k): (j > k? j: k);

（0.40秒）

在这些测试中，所有解决方案的执行时间都不超过其他解决方案的3%。您试图优化的代码非常简短。即使您能够从中挤出一条指令，也不可能在整个程序中产生巨大的差异（现代编译器可能会捕捉到这种小优化）。把时间花在别处

---

编辑：更新了测试，结果发现它仍然在优化之前的部分测试。希望它不再是了。

不确定这是否是最有效的，但它可能是，而且它肯定更短：

int maximum = max( max(i, j), k);

---

对于这样的问题，除了知道优化编译器在做什么以及硬件上有什么可用性之外，没有什么可以替代。如果您拥有的基本工具是二进制比较或二进制最大值，那么两个比较或最大值都是必要且充分的

我更喜欢伊格纳西奥的解决方案：

int ret = max(i,j);
ret = max(ret, k);
return ret;

result = i;
if (j > result)
  result = j;
if (k > result)
  result = k;
return result;

因为在常见的现代英特尔硬件上，编译器将发现只发出两条比较指令和两条

cmov

指令非常容易，这使得I-cache的负载更小，分支预测器的压力也比条件分支小。（而且，代码清晰易读。）如果您使用的是x86-64，编译器甚至会将所有内容都保存在寄存器中

---

请注意，您将很难将此代码嵌入到一个程序中，您的选择会产生影响…

我喜欢将条件跳转作为一种智力练习来消除。这是否对绩效有任何可测量的影响，我不知道：）

#包括
#包括
内联整数最大值（整数a、整数b）
{
int差=a-b；
int b_更大=差异>>标准：：数值限制：：数字；
返回a-（差值大于等于b_）；
}
最大整数（整数a、整数b、整数c）
{
返回最大值（最大值（a、b、c）；
}
int main（）
{
STD::CUT
有一个建议把它包含到N2485下的C++库中。这个建议很简单，所以我把下面的有意义的代码包含进去了。
template < typename T >
const T & max ( const T & a )
{ return a ; }

template < typename T , typename ... Args >
const T & max( const T & a , const T & b , const Args &... args )
{ return  max ( b > a ? b : a , args ...); }

模板
常数T&max（常数T&a）
{返回a；}
模板
常量T&max（常量T&a、常量T&b、常量参数和…参数）
{返回最大值（b>a？b:a，args…）}
我认为“最有效”您谈论的是性能，尽量不浪费计算资源。但您可能指的是编写更少的代码行，或者可能是源代码的可读性。我在下面提供一个示例，您可以从收到的答案中评估是否发现有用的内容，或者是否喜欢其他版本

/* Java version, whose syntax is very similar to C++. Call this program "LargestOfThreeNumbers.java" */
class LargestOfThreeNumbers{
    public static void main(String args[]){
        int x, y, z, largest;
        x = 1;
        y = 2;
        z = 3;
        largest = x;
        if(y > x){
            largest = y;
            if(z > y){
                largest = z;
            }
        }else if(z > x){
            largest = z;
        }
        System.out.println("The largest number is: " + largest);
    }
}

三个数字中最大的一个
#包括
int main（）
{
INTA、b、c、d、e；
scanf（“%d%d%d”、&a、&b和&c）；
d=（a+b+abs（a-b））/2；
e=（d+c+abs（c-d））/2；
printf（“%d为最大值\n”，e）；
返回0；
}
在C++中找到最大或最小2个或更多个数的最简单的方法是：-< /P>
int a = 3, b = 4, c = 5;
int maximum = max({a, b, c});

int a = 3, b = 4, c = 5;
int minimum = min({a, b, c});

您可以根据需要提供任意多的变量

有趣的是，它也非常有效，至少与伊格纳西奥·巴斯克斯-艾布拉姆斯的解决方案（）一样有效：

与GCC类似，而MSVC会弄乱循环。
在C#中查找3位数字之间的最大值和最小值

static void recorrectFindSmallestNumber()
{
int x = 30, y = 22, z = 11;
if (x < y)
{
if (x < z)
{
Console.WriteLine("X is Smaller Numebr {0}.", x);
}
else
{
Console.WriteLine("z is Smaller Numebr {0}.", z);
}
}
else if (x > y)
{
if (y < z)
{
Console.WriteLine("y is Smaller number.{0}", y);
}
else
{
Console.WriteLine("z is Smaller number.{0}", z);
}
}
 else
{

}
}

静态无效重新更正FindCallestNumber（）
{
int x=30，y=22，z=11；
if（xy），则为else
{
if（y

=================================================================

static void recorrectFindLargeNumber()
{
int x, y, z;
Console.WriteLine("Enter the first number:");
x = int.Parse(Console.ReadLine());
Console.WriteLine("Enter the second number:");
y = int.Parse(Console.ReadLine());
Console.WriteLine("Enter the third nuumnber:");
z = int.Parse(Console.ReadLine());
if (x > y)
{
if (x > z)
{
Console.WriteLine("X is Greater numbaer: {0}.", x);
}
else
{
Console.WriteLine("Z is greatest number: {0}.", z);
}
}
else if (x < y)
{
if (y > z)
{
Console.WriteLine("y is Greater Number: {0}", y);
}
else 
{
Console.WriteLine("Z is Greater Number; {0}", z);                
}
}
else
{
                
}
}

static void recocorrectFindLargeNumber（）
{
int x，y，z；
Console.WriteLine（“输入第一个数字：”）；
x=int.Parse（Console.ReadLine（））；
Console.WriteLine（“输入第二个数字：”）；
y=int.Parse（Console.ReadLine（））；
Console.WriteLine（“输入第三个number:”）；
z=int.Parse（Console.ReadLine（））；
如果（x>y）
{
如果（x>z）
{
WriteLine（“X是更大的numbaer:{0}.”，X）；
}
其他的
{
WriteLine（“Z是最大数：{0}.”，Z）；
}
}
else if（xz）
{
WriteLine（“y是更大的数字：{0}”，y）；
}
其他的
{
WriteLine（“Z是更大的数字；{0}”，Z）；
}
}
其他的
{
}
}
你能用这个吗？在这种情况下，如果是家庭作业，没关系，因为提问者已经尝试过，展示了他的代码，并要求改进。这符合张贴家庭作业问题的所有指导原则。@Robert Greiner哈哈，不。虽然这会是一个很好的家庭作业问题，但不是吗？@Stephano:你可以分析并确定它如果这是程序中的主要减速。担心每件事的效率是一个常见的错误；只需让代码易于理解和编写，让编译器完成它的一部分。下面是可能的最有效的方法：
/*前提条件：i是这三者中的最大值。*/int max（int i，int j，int k）{return i；}
或者可能只是返回42。可以做一个很好的小函数：
模板const T&max（const T&pA，const T&pB，const T&pC）{返回max（pA，max（pB，
        mov     eax, dword ptr [rsp + 8]
        mov     ecx, dword ptr [rsp + 4]
        cmp     eax, ecx
        cmovl   eax, ecx
        mov     ecx, dword ptr [rsp]
        cmp     eax, ecx
        cmovl   eax, ecx

static void recorrectFindSmallestNumber()
{
int x = 30, y = 22, z = 11;
if (x < y)
{
if (x < z)
{
Console.WriteLine("X is Smaller Numebr {0}.", x);
}
else
{
Console.WriteLine("z is Smaller Numebr {0}.", z);
}
}
else if (x > y)
{
if (y < z)
{
Console.WriteLine("y is Smaller number.{0}", y);
}
else
{
Console.WriteLine("z is Smaller number.{0}", z);
}
}
 else
{

}
}

static void recorrectFindLargeNumber()
{
int x, y, z;
Console.WriteLine("Enter the first number:");
x = int.Parse(Console.ReadLine());
Console.WriteLine("Enter the second number:");
y = int.Parse(Console.ReadLine());
Console.WriteLine("Enter the third nuumnber:");
z = int.Parse(Console.ReadLine());
if (x > y)
{
if (x > z)
{
Console.WriteLine("X is Greater numbaer: {0}.", x);
}
else
{
Console.WriteLine("Z is greatest number: {0}.", z);
}
}
else if (x < y)
{
if (y > z)
{
Console.WriteLine("y is Greater Number: {0}", y);
}
else 
{
Console.WriteLine("Z is Greater Number; {0}", z);                
}
}
else
{
                
}
}