有n个32位无符号整数，求其中异或之后结果最大的两个数

链接： http://discuss.joelonsoftware.com/default.asp?interview.11.614716

find the max value after XORing?

Give n 32bit numbers which are all unsigned integers, then find the
two numbers that can get the maximum value after their XOR.

e.g.

for
these numbers: 1, 2, 3, 4, 0xFFFFFFFE,

we should return 1 and
0xFFFFFFFE whose XOR result is the max.

please give a algorithm
with time complexity <= nlgn, O(n)would be better.

CSDN讨论地址： http://topic.csdn.net/u/20100511/12/3044a051-4fad-40bc-b312-325fa4b7617a.html?19376
解法1：
I think the best approach to this would be a series of bucket sorts
based on which bits of the numbers are set.

So you'd start by
bucket-sorting the inputs according to their highest set bit. That is,
the kth bucket gets all inputs between 2^k and 2^(k+1)-1. Now the
highest-value (nonempty) bucket is guaranteed to contain one of your
outputs.

Then, you'd want to sort the numbers in that bucket by
their highest unset bit (after the first set one). If the highest value
bucket of this second sort has a smallish number of elements, then you
would start comparing them to the comparable bucket from your first
sort, to find a maximal pair. If not, you could further sort them by the
highest set bit after the highest unset bit. And so on.

For
general data I think this would wind up close to O(N). But for perverse
inputs I suspect you'd wind up doing around logN sorts. So it smells
like an NlogN problem in the worst case.

Any of that sound right?

解法2:
I think this can be done in O(n).

I have a two-pass algorithm:

1.
The first pass builds a binary tree.

  . The tree has n leaves
corresponding to the n given numbers.

  . Each leaf has a depth of
32.

  . When you add a leaf, you start from the MSB, if 0 go left,
if 1 go right.

   

2. In the second pass, for each number x, bit
reverse (m=~x) it first, and then find the best "match" of m in the
tree.

  The "match" looks like the following:

  unsigned
long BestMatch(unsigned long m, node * pRoot) 

  {

     
unsigned long match = 0;

      for (int i=31; i>=0; i--)

 
    {

          match <<= 1;

          BYTE bit =
(m>>i)&0x01;

          if (bit)

          {

   
          if (p->right)

              {

                  p
= p->right;

                  match ++;

              }

 
            else

              {

                  p =
p->left;

              }

          }

          else

   
      {

              if (p->left)

              {

     
            p = p->left;

                  match ++;

       
      }

              else

              {

                 
p = p->right;

              }

          }

      }

   
 

      return match;

  }

收获：时间复杂度虽然 o(n) 要看着比 o(n*logn)好，但事实上有时候 o(n)实际上是o（k*n),而 k的大小并不一定比 log (n)好