Le moyen le plus efficace de trouver le plus grand des trois entiers

Pseudocode:

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

Votre méthode actuelle:
http://ideone.com/JZEqZTlj (0.40 s)

De Chris solution:

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

http://ideone.com/hlnl7QZX (0.39 s)

Solution par Ignacio Vazquez-Abrams:

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

http://ideone.com/JKbtkgXi (0.40 s)

Et Charles Bretana de l':

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

http://ideone.com/kyl0SpUZ (0.40 s)

De ces tests, toutes les solutions à moins de 3% de la quantité de temps pour s'exécuter que les autres. Le code que vous essayez d'optimiser est extrêmement court comme il est. Même si vous êtes capable de faire 1 instruction hors de lui, il n'est pas de nature à faire une énorme différence sur l'ensemble de votre programme (les compilateurs modernes peut attraper cette petite optimisation). Passer votre temps ailleurs.

EDIT: mis à Jour les tests, il s'avère que c'était encore l'optimisation des pièces de l'avant. J'espère que c'est pas plus.

Je tiens à éliminer les sauts conditionnels comme un exercice intellectuel. Si cela a aucun effet mesurable sur la performance, je n'ai aucune idée de bien 🙂

#include <iostream>
#include <limits>

inline int max(int a, int b)
{
    int difference = a - b;
    int b_greater = difference >> std::numeric_limits<int>::digits;
    return a - (difference & b_greater);
}

int max(int a, int b, int c)
{
    return max(max(a, b), c);
}

int main()
{
    std::cout << max(1, 2, 3) << std::endl;
    std::cout << max(1, 3, 2) << std::endl;
    std::cout << max(2, 1, 3) << std::endl;
    std::cout << max(2, 3, 1) << std::endl;
    std::cout << max(3, 1, 2) << std::endl;
    std::cout << max(3, 2, 1) << std::endl;
}

Ce bit se tourner, c'est juste pour le fun, la cmov solution est probablement beaucoup plus rapide.

Il y a une proposition visant à inclure dans la bibliothèque C++ sous N2485. La proposition est simple, donc, je ai inclus le code ci-dessous. Évidemment, cela suppose que les variadic templates

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 ...); }

Je pense que par "les plus efficaces" vous parlez de la performance, en essayant de ne pas gaspiller les ressources de calcul. Mais vous pourriez être en se référant à l'écriture de moins de lignes de code ou peut-être sur la lisibilité de votre code source. Je suis en fournissant un exemple ci-dessous, et vous pouvez évaluer si vous trouverez quelque chose d'utile ou si vous préférez une autre version à partir des réponses que vous avez reçu.

/* 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);
    }
}

Plus de 3 numéros

int greater = a>b ? (a>c? a:c) :(b>c ? b:c); 
System.out.println(greater);