不用判断语句，求两个数的最大值

一, 利用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)];
	}
方法多出于参考与总结