剑指offer67：最大的异或

题目：
给定一个整数数组 nums ，返回 nums[i] XOR nums[j] 的最大运算结果，其中 0 ≤ i ≤ j < n 。（计算其中任意两个数字的异或最大值）
输入：nums = [3,10,5,25,2,8]
输出：28
解释：最大运算结果是 5 XOR 25 = 28.
分析：
异或的特点是如果两个相同数位异或的结果是0，那么相反的数位异或结果为1，如果想找到某个整数k和其他整数的最大异或值，尽量找和k数位不同的整数。
这题目可以直接使用蛮力法，找出所有可能由两个数字组成的数对并求出它们的异或，通过比较就能得到最大的异或值，如果整数数组长度为n，那么直观的算法时间复杂度为O（n^2）。
该问题可以变成查找问题，而且是按照整数二进制数位进行查找的问题，需要将整数数位都保存下来，前缀树就可以做到，并且整数都是32位的，整数在前缀树中对应的路径长度都是一样的。
具体操作看代码。
针对这段代码，可能不太好理解，可以看下面的图片推导，由于异或是不同为1，相同为0，1更大，并且1出现在高位更大，因此我们从最高位开始找不同，根据一个数字对应的数位，从高位开始在前缀树中找与其不同的数位，找到不同的数位xor也就是异或值就左移一位后加1，然后到其孩子节点接着判断是否和数字的下一个数位不同，以此类推，如果相同xor左移一位不加1，一直到数字数位遍历完就能找到该数字的最大异或值，然后接着判断下一个数字的最大异或值，最后选出整个数组最大的异或值、

 for (int i = 31; i >= 0; i--) {
                int bit = (num >> i)&1;
//                如果前缀树中存在某个整数的相同位置的数位和num的数位相反，则优先选择相反的数位
//                这是因为两个相反的数位异或的结果为1
                 if (node.children[1-bit] !=null){
                     xor = (xor<<1) + 1;
                     node = node.children[1-bit];
                 }else {
                     xor = xor<<1;
                     node = node.children[bit];
                 }
                 max = Math.max(max,xor);
            }

由于两个函数都有两层循环，第一层循环逐个扫描数组中的每个整数，而二层循环的执行次数是32次，是一个常数因此该算法时间复杂度为O（n）。
代码：

public class FindMaximumXOR {
    public static void main(String[] args) {
        FindMaximumXOR findMaximumXOR = new FindMaximumXOR();
        int[] nums = {3,10,5,25,2,8};
        int maximumXOR = findMaximumXOR.findMaximumXOR(nums);
        System.out.println(maximumXOR);
    }
    static class TrieNode{
        public TrieNode[] children;

        public TrieNode() {
            children = new TrieNode[2];
        }
    }
//    由于整数都是32位的，前缀树对应的路径长度是一样的
    public TrieNode buildTrie(int[] nums){
        TrieNode root = new TrieNode();
        for (int num : nums) {
            TrieNode node = root;
            for (int i = 31; i >=0 ; i--) {
//                bit相当于一个数字的32位通过循环依次从第1位到第32位的数字
                int bit = (num >> i)&1;
                if (node.children[bit] == null){
                    node.children[bit] = new TrieNode();
                }
                node = node.children[bit];
            }
        }
        return root;
    }
    public int findMaximumXOR(int[] nums){
        TrieNode root = buildTrie(nums);
        int max = 0;
        for (int num :nums){
            TrieNode node = root;
//            xor为异或值
            int xor = 0;
//            从高位开始扫描整数num的每个数位
            for (int i = 31; i >= 0; i--) {
            //bit是num的一个数位
                int bit = (num >> i)&1;
//                如果前缀树中存在某个整数的相同位置的数位和num的数位相反，则优先选择相反的数位
//                这是因为两个相反的数位异或的结果为1
                 if (node.children[1-bit] !=null){
                     xor = (xor<<1) + 1;
                     node = node.children[1-bit];
                 }else {
                     xor = xor<<1;
                     node = node.children[bit];
                 }
                 max = Math.max(max,xor);
            }
        }
        return max;
    }
}