数组中两个数的最大XOR

介绍

给定一个整数数组nums，从中选择两个数，求这两个数的按位异或（XOR）结果的最大值。

例如，对于数组[3, 10, 5, 25, 2, 8]，可以选择10和25，它们的按位异或结果为10^25=27，是所有选择中最大的。

思路

此问题的主要思路是将nums数组中的每个数按位拆分，并将它们存储在一个二叉树中。然后，对于每个数，从根节点开始，将它的每个二进制位与树中的对应项进行比较，并向下移动。这样，可以得到一个由nums数组中每个数字表示的二进制树。

接下来，对于每个数，从树的根节点开始，找到它的最高位异或值。然后，从根节点开始，沿着该最高位找到最大的异或值。这样，就可以找到该数可以与nums数组中哪个数字进行异或以获得最大的结果。

最后，遍历数组nums，对于每个数字，找到位于二叉树中的位于最高位异或值的下面的最大异或值并返回。

代码

Python

class TrieNode:
    def __init__(self):
        self.zero = None
        self.one = None
        
class Trie:
    def __init__(self):
        self.root = TrieNode()
    
    def insert(self, num):
        node = self.root
        for i in range(31, -1, -1):
            bit = (num >> i) & 1
            if bit == 0:
                if not node.zero:
                    node.zero = TrieNode()
                node = node.zero
            else:
                if not node.one:
                    node.one = TrieNode()
                node = node.one
                
    def findMaxXor(self, num):
        node = self.root
        xor = 0
        for i in range(31, -1, -1):
            bit = (num >> i) & 1
            if bit == 0:
                if node.one:
                    xor += (1 << i)
                    node = node.one
                else:
                    node = node.zero
            else:
                if node.zero:
                    xor += (1 << i)
                    node = node.zero
                else:
                    node = node.one
        return xor
        
class Solution:
    def findMaximumXOR(self, nums: List[int]) -> int:
        trie = Trie()
        for num in nums:
            trie.insert(num)
        maxXor = 0
        for num in nums:
            maxXor = max(maxXor, trie.findMaxXor(num))
        return maxXor

Java

class TrieNode {
    TrieNode zero;
    TrieNode one;
}

class Trie {
    TrieNode root;
    
    Trie() {
        root = new TrieNode();
    }
    
    public void insert(int num) {
        TrieNode node = root;
        for (int i = 31; i >= 0; i--) {
            int bit = (num >> i) & 1;
            if (bit == 0) {
                if (node.zero == null) {
                    node.zero = new TrieNode();
                }
                node = node.zero;
            } else {
                if (node.one == null) {
                    node.one = new TrieNode();
                }
                node = node.one;
            }
        }
    }
    
    public int findMaxXor(int num) {
        TrieNode node = root;
        int xor = 0;
        for (int i = 31; i >= 0; i--) {
            int bit = (num >> i) & 1;
            if (bit == 0) {
                if (node.one != null) {
                    xor += (1 << i);
                    node = node.one;
                } else {
                    node = node.zero;
                }
            } else {
                if (node.zero != null) {
                    xor += (1 << i);
                    node = node.zero;
                } else {
                    node = node.one;
                }
            }
        }
        return xor;
    }
}

class Solution {
    public int findMaximumXOR(int[] nums) {
        Trie trie = new Trie();
        for (int num : nums) {
            trie.insert(num);
        }
        int maxXor = 0;
        for (int num : nums) {
            maxXor = Math.max(maxXor, trie.findMaxXor(num));
        }
        return maxXor;
    }
}

复杂度

该算法的时间复杂度为O(nlogn)，其中n为数组大小。具体解释如下：

• 将每个数字插入Trie中，需要O(logn)的时间。
• 对于每个数字，需要O(logn)的时间在Trie中寻找最大的异或值。
• 总时间复杂度为O(nlogn)。

该算法的空间复杂度为O(nlogn)，其中n为数组大小。具体解释如下：

• 插入所有数字需要O(nlogn)的空间，因为Tire的大小取决于数字数量和每个数字的二进制位数。
• 存储的所有数字在Trie中占用O(nlogn)的空间，因为每个数字占用O(logn)的空间。
• 总空间复杂度为O(nlogn)。