不用判斷語句，求兩個數的最大值

一, 利用abs() 求絕對值

int GetMax(int a, int b)

{

return (a + b + abs(a - b)) / 2;

}

二, 通過位元運算計算正負數

#define signal_bit(x) ( x >> (sizeof(int) * 8 -1) & 1)

int GetMax( int a, int b )
{
int hash[2] = {a, b};
int index = signal_bit(a - b);
return hash[index];
}

三, 建立映射表,

#define signed_bit(x)      (( (x) & 0x80000000) >> 31)
#define value_stuff(x)     ( x & 0x7FFFFFFF)
#define value_diff(x, y) signed_bit( value_stuff(x) - value_stuff(y) )

int GetMax( int x, int y)
{
  int nums[2][2][2] = 
  {
                x,                //000
                y,                //001
                x,                //010
                x,                //011
                y,                //100
                y,                //101
                x,                //110
                y                 //111
  };

  int idx0 = signed_bit(x);
  int idx1 = signed_bit(y);
  int idx2 = value_diff(x, y);

  return nums[idx0][idx1][idx2];
}

x,                //000 x為正數，y為正數，x負載>=y， 那麼x為最大值

y,                //001 x為正數，y為正數，x負載<y， 那麼y為最大值

x,                //010 x為正數，y為負數，那麼x為最大值 （無需考慮負載部分）

x,                //011 x為正數，y為負數，那麼x為最大值（無需考慮負載部分）

y,                //100 x為負數，y為正數，那麼y為最大值（無需考慮負載部分）

y,                //101 x為負數，y為正數，那麼y為最大值（無需考慮負載部分）

x,                //110 x為負數，y為負數，x負載>=y， 那麼x為最大值

y                 //111 x為負數，y為負數，x負載<y， 那麼y為最大值 四, "妙"莫過於此了

int GetMax (int x, int y)
{
int xy, yx;

xy = ((x - y) >> 31) & 1;
yx = ((y - x) >> 31) & 1;
return xy * y + yx * x + (1 - xy - yx) * x;
}

如果x>y, xy = 0; xy * y = 0; yx = 1; yx * x = x;

如果x<y, xy = 1; xy * y = y; yx = 0; yx * x = 0;

如果x=y, xy = 0; yx = 0;  

五, 可是只有更, 沒有最

int GetMax(int x,int y)
{
unsigned int z;
z=((x-y)>>31)&1;
return (1-z)*x+z*y;　　　　　　　　
}

六, 可是 溢出了怎麼辦

// x y 一為正   一為負   擷取正數

int GetPositive( int x, int y ){unsigned int z;z = x >> 31 & 1;return z * y + (1 - z) * x;}

int GetMaxOverflow(int x, int y)

{

unsigned int z;

z = x ^ y >> 31 & 1;

return (1 - z)GetMax(x, y) + z * GetPositive(x, y);

}

七, x + y ; x - y ; 有溢出, 那就不用

#define SHIFT (sizeof(int) * 8 - 1)
int GetMax(int x, int y)
{
unsigned int m, n;
int ary[2] = {x, y};

m = x ^ y;
m = m & ~(m / 2) & ~(m / 4);
n = m | 0x01;

return ary[ ((x & n) + n / 2) / n ^ !(m >> SHIFT)];
}

方法多出於參考與總結