Die meisten effizienten Art und Weise zu finden, die größte der drei ints

Pseudocode:

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

Deine aktuelle Methode:
http://ideone.com/JZEqZTlj (0.40 s)

Chris ' s Lösung:

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

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

Lösung von Ignacio Vazquez-Abrams:

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

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

Charles Bretana s:

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

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

Tests, alle Lösungen sind innerhalb von 3% der Höhe der Zeit zu führen als die anderen. Der code, den Sie versuchen zu optimieren sind extrem kurz, wie es ist. Auch wenn Sie sind in der Lage, squeeze 1 Anleitung aus, ist es wahrscheinlich nicht machen einen großen Unterschied über die Gesamtheit des Programms (Compilern fangen könnte, dass kleine Optimierung). Verbringen Sie Ihre Zeit an anderer Stelle.

EDIT: Aktualisiert den tests stellt sich heraus, es war immer noch die Optimierung von teilen davon vor. Hoffentlich ist es nicht mehr.

Ich gerne beseitigen bedingte Sprünge als eine Intellektuelle übung. Ob das hat keine messbare Auswirkung auf die performance habe ich keine Idee, obwohl 🙂

#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;
}

Dieses bit twiddling ist einfach nur zum Spaß, die cmov Lösung ist wahrscheinlich viel schneller.

Es ist ein Vorschlag, um diese in die C++ - Bibliothek unter N2485. Der Vorschlag ist einfach, also ich habe den sinnvollen code. Natürlich, dies setzt Voraus, 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 ...); }

Ich denke, durch die "effizienteste" Sie sprechen über Leistung, versuchte, nicht zu verschwenden computing-Ressourcen. Aber Sie konnte sich auf das schreiben weniger code-Zeilen oder vielleicht über die Lesbarkeit des Quellcodes. Ich bin ein Beispiel unter, und können Sie auswerten, wenn Sie etwas finden, nützlich, oder wenn Sie lieber eine andere version von den Antworten, die Sie erhalten.

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

Größte von 3 zahlen

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