Gemini永久会员 go数组中最大异或值

在Go语言中寻找数组中两个元素的最大异或值，同样可以采用暴力解法、位运算+哈希集合或字典树（Trie）的方法。以下是对应的实现：

---

1. 暴力解法（O(n²)）

package main

import "fmt"

func findMaximumXOR(nums []int) int {
    maxXOR := 0
    n := len(nums)
    for i := 0; i < n; i++ {
        for j := i + 1; j < n; j++ {
            current := nums[i] ^ nums[j]
            if current > maxXOR {
                maxXOR = current
            }
        }
    }
    return maxXOR
}

func main() {
    nums := []int{3, 10, 5, 25, 2, 8}
    fmt.Println("Maximum XOR:", findMaximumXOR(nums)) // 输出28 (5 ^ 25)
}

---

2. 位运算+哈希集合（O(n)）

package main

import "fmt"

func findMaximumXOR(nums []int) int {
    maxXOR := 0
    mask := 0
    for i := 31; i >= 0; i-- {
        mask |= 1 << uint(i)
        prefixes := make(map[int]bool)
        
        for _, num := range nums {
            prefixes[num & mask] = true
        }
        
        temp := maxXOR | (1 << uint(i))
        for prefix := range prefixes {
            if prefixes[prefix ^ temp] {
                maxXOR = temp
                break
            }
        }
    }
    return maxXOR
}

func main() {
    nums := []int{3, 10, 5, 25, 2, 8}
    fmt.Println("Maximum XOR:", findMaximumXOR(nums)) // 输出28
}

---

3. 字典树（Trie）实现

package main

import "fmt"

type TrieNode struct {
    children [2]*TrieNode
}

func findMaximumXOR(nums []int) int {
    root := &TrieNode{}
    maxXOR := 0

    for _, num := range nums {
        node := root
        xorNode := root
        currentXOR := 0

        for i := 31; i >= 0; i-- {
            bit := (num >> uint(i)) & 1
            // 插入到Trie中
            if node.children[bit] == nil {
                node.children[bit] = &TrieNode{}
            }
            node = node.children[bit]

            // 计算当前位的异或
            toggledBit := 1 - bit
            if xorNode != nil {
                if xorNode.children[toggledBit] != nil {
                    currentXOR += 1 << uint(i)
                    xorNode = xorNode.children[toggledBit]
                } else {
                    xorNode = xorNode.children[bit]
                }
            }
        }
        if currentXOR > maxXOR {
            maxXOR = currentXOR
        }
    }
    return maxXOR
}

func main() {
    nums := []int{3, 10, 5, 25, 2, 8}
    fmt.Println("Maximum XOR:", findMaximumXOR(nums)) // 输出28
}

---

总结

1. 暴力解法：适合小型数组，代码简单但效率低（O(n²)）。
2. 位运算+哈希集合：中型数组的首选，时间复杂度O(n)，利用位掩码逐步构建最大异或值。
3. 字典树：适合超大型数组，时间复杂度O(n)，但实现较复杂，常数因子较大。

根据数组规模和性能需求选择合适的方法。Go的实现与Java/Python逻辑一致，但语法更简洁（如位运算的>> uint(i)避免负数移位问题）。