Maximum XOR of Two Numbers in an Array | Set 2

20 Jun, 2022
Given an array arr[] consisting of N integers, the task is to find the maximum Bitwise XOR from all the possible pairs in the given array.
Examples:
Input: arr[] = {25, 10, 2, 8, 5, 3}Output: 28Explanation:The maximum result is 5^25 = 28.
Input: arr[] = {1, 2, 3, 4, 5, 6, 7}Output: 7Explanation:The maximum result is 1^6 = 7.
Naive Approach: Refer to the article Maximum XOR of Two Numbers in an Array for the simplest approach to solve the problem by generating all pairs of the given array and computing XOR of each pair to find the maximum among them.
Time Complexity: O(N2)Auxiliary Space: O(1)
Bitmasking Approach:  Refer to the article Maximum XOR of Two Numbers in an Array to solve the problem using Bitmasking.
Time Complexity: O(N*log M), where M is the maximum number present in the array Auxiliary Space: O(N)
Efficient Approach: The above approach can be solved by using Trie by inserting the binary representation of the numbers in the array arr[]. Now iterate the binary representation of all the elements in the array arr[] and if the current bit is 0 then find the path with value 1 or vice-versa in the Trie to get the maximum value of Bitwise XOR. Update the maximum value for each number. Below are the steps:
Initialize maximumXOR as 0.Insert the binary representation of all the numbers in the given array arr[] in the Tree. While inserting in the trie if the current bit 0 then create a node in the left else create a node in the right of the current head node.Now, traverse the given array and for each element do the following:Initialize the currentXOR value as 0.Traverse the binary representation of the current number.If ith bit is 1 and node->left exists then update currentXOR as currentXOR + pow(2, i) and update node as node->left. Else update node = node->right.If ith bit is 0, and node->right exists then update currentXOR as currentXOR + pow(2, i) and update node as node->right. Else update node = node->left.For each array element in the above step, update the maximumXOR value if maximumXOR is greater than currentXOR.Print the value of maximumXOR after the above steps.
Initialize maximumXOR as 0.
Insert the binary representation of all the numbers in the given array arr[] in the Tree. While inserting in the trie if the current bit 0 then create a node in the left else create a node in the right of the current head node.
Now, traverse the given array and for each element do the following:Initialize the currentXOR value as 0.Traverse the binary representation of the current number.If ith bit is 1 and node->left exists then update currentXOR as currentXOR + pow(2, i) and update node as node->left. Else update node = node->right.If ith bit is 0, and node->right exists then update currentXOR as currentXOR + pow(2, i) and update node as node->right. Else update node = node->left.
Initialize the currentXOR value as 0.
Traverse the binary representation of the current number.
If ith bit is 1 and node->left exists then update currentXOR as currentXOR + pow(2, i) and update node as node->left. Else update node = node->right.
If ith bit is 0, and node->right exists then update currentXOR as currentXOR + pow(2, i) and update node as node->right. Else update node = node->left.
For each array element in the above step, update the maximumXOR value if maximumXOR is greater than currentXOR.
Print the value of maximumXOR after the above steps.
Below is the implementation of the above approach:
C++
Java
Python3
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>using namespace std; // Structure of Trieclass node {public:    node* left;    node* right;}; // Function to insert binary// representation of element x// in the Trievoid insert(int x, node* head){    // Store the head    node* curr = head;     for (int i = 30; i >= 0; i--) {         // Find the i-th bit        int val = (x >> i) & 1;         if (val == 0) {             // If curr->left is NULL            if (!curr->left)                curr->left = new node();             // Update curr to curr->left            curr = curr->left;        }        else {             // If curr->right is NULL            if (!curr->right)                curr->right = new node();             // Update curr to curr->right            curr = curr->right;        }    }} // Function that finds the maximum// Bitwise XOR value for all such pairsint findMaximumXOR(int arr[], int n){    // head Node of Trie    node* head = new node();     // Insert each element in trie    for (int i = 0; i < n; i++) {        insert(arr[i], head);    }     // Stores the maximum XOR value    int ans = 0;     // Traverse the given array    for (int i = 0; i < n; i++) {         // Stores the XOR with current        // value arr[i]        int curr_xor = 0;         int M = pow(2, 30);         node* curr = head;         for (int j = 30; j >= 0; j--) {             // Finding ith bit            int val = (arr[i] >> j) & 1;             // Check if the bit is 0            if (val == 0) {                 // If right node exists                if (curr->right) {                     // Update the currentXOR                    curr_xor += M;                    curr = curr->right;                }                 else {                    curr = curr->left;                }            }             else {                 // Check if left node exists                if (curr->left) {                     // Update the currentXOR                    curr_xor += M;                    curr = curr->left;                }                else {                    curr = curr->right;                }            }             // Update M to M/2 for next set bit            M /= 2;        }         // Update the maximum XOR        ans = max(ans, curr_xor);    }     // Return the maximum XOR found    return ans;} // Driver Codeint main(){    // Given array arr[]    int arr[] = { 1, 2, 3, 4 };     int N = sizeof(arr) / sizeof(arr[0]);     // Function Call    cout << findMaximumXOR(arr, N);     return 0;}
// Java program for the above approachimport java.util.*; class GFG{ // Structure of Triestatic class node{    node left;    node right;}; // Function to insert binary// representation of element x// in the Triestatic void insert(int x, node head){         // Store the head    node curr = head;     for(int i = 30; i >= 0; i--)    {                 // Find the i-th bit        int val = (x >> i) & 1;         if (val == 0)        {                         // If curr.left is null            if (curr.left == null)                curr.left = new node();             // Update curr to curr.left            curr = curr.left;        }        else        {                         // If curr.right is null            if (curr.right == null)                curr.right = new node();             // Update curr to curr.right            curr = curr.right;        }    }} // Function that finds the maximum// Bitwise XOR value for all such pairsstatic int findMaximumXOR(int arr[], int n){         // head Node of Trie    node head = new node();     // Insert each element in trie    for(int i = 0; i < n; i++)    {        insert(arr[i], head);    }     // Stores the maximum XOR value    int ans = 0;     // Traverse the given array    for(int i = 0; i < n; i++)    {                 // Stores the XOR with current        // value arr[i]        int curr_xor = 0;         int M = (int)Math.pow(2, 30);         node curr = head;         for(int j = 30; j >= 0; j--)        {                         // Finding ith bit            int val = (arr[i] >> j) & 1;             // Check if the bit is 0            if (val == 0)            {                 // If right node exists                if (curr.right != null)                {                                         // Update the currentXOR                    curr_xor += M;                    curr = curr.right;                }                else                {                    curr = curr.left;                }            }             else            {                                 // Check if left node exists                if (curr.left != null)                {                                         // Update the currentXOR                    curr_xor += M;                    curr = curr.left;                }                else                {                    curr = curr.right;                }            }             // Update M to M/2 for next set bit            M /= 2;        }         // Update the maximum XOR        ans = Math.max(ans, curr_xor);    }     // Return the maximum XOR found    return ans;} // Driver Codepublic static void main(String[] args){         // Given array arr[]    int arr[] = { 1, 2, 3, 4 };     int N = arr.length;     // Function call    System.out.print(findMaximumXOR(arr, N));}} // This code is contributed by Amit Katiyar
# Python program for the above approach # Structure of Trieclass node:    def __init__(self):        self.left = None        self.right = None # Function to insert binary# representation of element x# in the Triedef insert(x,  head):     # Store the head    curr = head     for i in range(30, -1, -1):         # Find the i-th bit        val = (x >> i) & 1         if (val == 0):             # If curr.left is null            if (curr.left == None):                curr.left = node()             # Update curr to curr.left            curr = curr.left        else:             # If curr.right is null            if (curr.right == None):                curr.right = node()             # Update curr to curr.right            curr = curr.right  # Function that finds the maximum# Bitwise XOR value for all such pairsdef findMaximumXOR(arr, n):     # head Node of Trie    head = node()     # Insert each element in trie    for i in range(n):        insert(arr[i], head)     # Stores the maximum XOR value    ans = 0     # Traverse the given array    for i in range(n):         # Stores the XOR with current        # value arr[i]        curr_xor = 0         M = 2 ** 30         curr = head         for j in range(30, -1, -1):             # Finding ith bit            val = (arr[i] >> j) & 1             # Check if the bit is 0            if (val == 0):                 # If right node exists                if (curr.right != None):                     # Update the currentXOR                    curr_xor += M                    curr = curr.right                else:                    curr = curr.left             else:                 # Check if left node exists                if (curr.left != None):                     # Update the currentXOR                    curr_xor += M                    curr = curr.left                else:                    curr = curr.right             # Update M to M/2 for next set bit            M = M//2         # Update the maximum XOR        ans = max(ans, curr_xor)     # Return the maximum XOR found    return ans # Driver Code # Given array arrarr = [1, 2, 3, 4] N = len(arr) # Function callprint(findMaximumXOR(arr, N)) # This code is contributed by Saurbah Jaiswal
// C# program for// the above approachusing System;class GFG{ // Structure of Treepublic class node{  public node left;  public node right;}; // Function to insert binary// representation of element// x in the Treestatic void insert(int x,                   node head){  // Store the head  node curr = head;   for(int i = 30; i >= 0; i--)  {    // Find the i-th bit    int val = (x >> i) & 1;     if (val == 0)    {      // If curr.left is null      if (curr.left == null)        curr.left = new node();       // Update curr to curr.left      curr = curr.left;    }    else    {      // If curr.right is null      if (curr.right == null)        curr.right = new node();       // Update curr to curr.right      curr = curr.right;    }  }} // Function that finds the maximum// Bitwise XOR value for all// such pairsstatic int findMaximumXOR(int []arr,                          int n){     // Head Node of Tree  node head = new node();   // Insert each element in tree  for(int i = 0; i < n; i++)  {    insert(arr[i], head);  }   // Stores the maximum XOR value  int ans = 0;   // Traverse the given array  for(int i = 0; i < n; i++)  {    // Stores the XOR with    // current value arr[i]    int curr_xor = 0;     int M = (int)Math.Pow(2, 30);    node curr = head;     for(int j = 30; j >= 0; j--)    {      // Finding ith bit      int val = (arr[i] >> j) & 1;       // Check if the bit is 0      if (val == 0)      {        // If right node exists        if (curr.right != null)        {          // Update the currentXOR          curr_xor += M;          curr = curr.right;        }        else        {          curr = curr.left;        }      }       else      {        // Check if left node exists        if (curr.left != null)        {          // Update the currentXOR          curr_xor += M;          curr = curr.left;        }        else        {          curr = curr.right;        }      }       // Update M to M/2      // for next set bit      M /= 2;    }     // Update the maximum XOR    ans = Math.Max(ans, curr_xor);  }   // Return the maximum  // XOR found  return ans;} // Driver Codepublic static void Main(String[] args){     // Given array []arr  int []arr = {1, 2, 3, 4};   int N = arr.Length;   // Function call  Console.Write(findMaximumXOR(arr, N));}} // This code is contributed by Rajput-Ji
<script>// javascript program for the above approach     // Structure of Trie     class node {         constructor() {                                 this.left = null;                this.right = null;            }     }    // Function to insert binary    // representation of element x    // in the Trie    function insert(x,  head) {         // Store the head        var curr = head;         for (i = 30; i >= 0; i--) {             // Find the i-th bit            var val = (x >> i) & 1;             if (val == 0) {                 // If curr.left is null                if (curr.left == null)                    curr.left = new node();                 // Update curr to curr.left                curr = curr.left;            } else {                 // If curr.right is null                if (curr.right == null)                    curr.right = new node();                 // Update curr to curr.right                curr = curr.right;            }        }    }     // Function that finds the maximum    // Bitwise XOR value for all such pairs    function findMaximumXOR(arr , n) {         // head Node of Trie        var head = new node();         // Insert each element in trie        for (var i = 0; i < n; i++) {            insert(arr[i], head);        }         // Stores the maximum XOR value        var ans = 0;         // Traverse the given array        for (i = 0; i < n; i++) {             // Stores the XOR with current            // value arr[i]            var curr_xor = 0;             var M = parseInt( Math.pow(2, 30));             var curr = head;             for (j = 30; j >= 0; j--) {                 // Finding ith bit                var val = (arr[i] >> j) & 1;                 // Check if the bit is 0                if (val == 0) {                     // If right node exists                    if (curr.right != null) {                         // Update the currentXOR                        curr_xor += M;                        curr = curr.right;                    } else {                        curr = curr.left;                    }                }                 else {                     // Check if left node exists                    if (curr.left != null) {                         // Update the currentXOR                        curr_xor += M;                        curr = curr.left;                    } else {                        curr = curr.right;                    }                }                 // Update M to M/2 for next set bit                M = parseInt(M/2);            }             // Update the maximum XOR            ans = Math.max(ans, curr_xor);        }         // Return the maximum XOR found        return ans;    }     // Driver Code              // Given array arr        var arr = [ 1, 2, 3, 4 ];         var N = arr.length;         // Function call        document.write(findMaximumXOR(arr, N)); // This code is contributed by umadevi9616</script>
7
 
Time Complexity: O(32*N)Auxiliary Space: O(32*N)
amit143katiyar
Rajput-Ji
umadevi9616
_saurabh_jaiswal
Bitwise-XOR
Trie
Advanced Data Structure
Arrays
Bit Magic
Mathematical
Searching
Arrays
Searching
Mathematical
Bit Magic
Trie
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Decision Tree Introduction with example
Count of strings whose prefix match with the given string to a given length k
Binary Indexed Tree or Fenwick Tree
Ordered Set and GNU C++ PBDS
AVL Tree | Set 2 (Deletion)
Arrays in Java
Write a program to reverse an array or string
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Largest Sum Contiguous Subarray