Finding Odd Occurrence of a Number in Java

An array of non-negative integers is given such that every number is occurring even number of times, barring one number which is occurring an odd number of times. The task is to find that number that is occurring an odd number of times.

Examples:

Input: a[] = {7, 4, 5, 4, 5, 7, 5, 9, 8, 9, 6, 8, 6}

Output: 5

Explanation: Apart from 5, all the other numbers are occurring even number of times. Note that the number 5 occurs 3 times in the input array, which is odd.

Input: a[] = {4, 3, 9, 3, 4, 9, 4, 7, 4, 7, 4}

Output: 4

Explanation: Apart from 4, all the other numbers are occurring even number of times. Note that the number 4 occurs 5 times in the input array, which is odd.

Naive Approach

The straightforward solution is to use two loops. The outer loop will pick a number, and the inner loop will count the frequency of the occurrence of that number. If the frequency of the occurrence is even, then we discard that number. If the frequency of the occurrence is odd, then we return that number.

FileName: OddOccurrence.java

public class OddOccurrence
{

public int findOddOccurrence(int a[], int size)
{

// outer loop picks the element a[y]
for (int y = 0; y < size; y++)
{

// for counting the number of
// times a number is coming in the array a[]
int countFreq = 0;

for (int j = 0; j < size; j++)
{
    if(a[y] == a[j])
    {
        // reaching here means we have found an occurrence
        // of the number a[y]
        countFreq = countFreq + 1;    
    }
}

if(countFreq % 2 == 1)
{
    return  a[y];
}

}
return -1;
}
      
// main method
public static void main(String argvs[])
{

// creating an object of the class OddOccurrence
OddOccurrence obj = new OddOccurrence();

// input array
int a[] = {7, 4, 5, 4, 5, 7, 5, 9, 8, 9, 6, 8, 6};

// computing the size of the array
int size = a.length;


// displaying the result
System.out.println("In the following input array: ");

for(int i = 0; i < a.length; i++)
{
System.out.print(a[i] + " ");    
}
System.out.println();
int result = obj.findOddOccurrence(a, size);

System.out.println("The number whose occurrence is odd is: " + result);

System.out.println();

// input array
int a1[] = {4, 3, 9, 3, 4, 9, 4, 7, 4, 7, 4};

// computing the size of the array
size = a1.length;

// displaying the result
System.out.println("In the following input array: ");

for(int i = 0; i < a1.length; i++)
{
System.out.print(a1[i] + " ");    
}
System.out.println();
result = obj.findOddOccurrence(a1, size);

System.out.println("The number whose occurrence is odd is: " + result);

}
}

Output:

In the following input array: 
7 4 5 4 5 7 5 9 8 9 6 8 6 
The number whose occurrence is odd is: 5

In the following input array: 
4 3 9 3 4 9 4 7 4 7 4 
The number whose occurrence is odd is: 4

Time Complexity: The above program uses two loops that have been nested. Therefore, the time complexity is O(n²), where n is the total number of elements present in the input array.

Space Complexity: The above program is not using any extra space. Therefore, the space complexity of the above program is O(1).

Finding Odd Occurrence of a Number Using Array

We can use an array to store the frequency of the occurrence of the elements. Then, we can check the numbers whose frequency is odd. The following program demonstrates the same.

FileName: OddOccurrence1.java

public class OddOccurrence1
{

// method for finding the maximum element
public int findMax(int a[], int size)
{
int ans = 0;
for(int i = 0 ; i < size; i++)
{
if(ans < a[i])
{
ans = a[i];
}
}
    
return ans;
}

public int findOddOccurrence(int a[], int size)
{
int ans = findMax(a, size);

// for storing the frequency of elements
int storeFreq[] = new int[ans + 1];

int len = ans + 1;


for(int j = 0; j < size; j++)
{
storeFreq[a[j]] = storeFreq[a[j]] + 1;
}

for(int i = 0; i < len; i++)
{
if(storeFreq[i] % 2 == 1)
{
return i;
}



}
return -1;

}


// main method
public static void main(String argvs[])
{

// creating an object of the class OddOccurrence1
OddOccurrence1 obj = new OddOccurrence1();

// input array
int a[] = {7, 4, 5, 4, 5, 7, 5, 9, 8, 9, 6, 8, 6};

// computing the size of the array
int size = a.length;


// displaying the result
System.out.println("In the following input array: ");

for(int i = 0; i < a.length; i++)
{
System.out.print(a[i] + " ");    
}
System.out.println();
int result = obj.findOddOccurrence(a, size);

System.out.println("The number whose occurrence is odd is: " + result);

System.out.println();

// input array
int a1[] = {4, 3, 9, 3, 4, 9, 4, 7, 4, 7, 4};

// computing the size of the array
size = a1.length;

// displaying the result
System.out.println("In the following input array: ");

for(int i = 0; i < a1.length; i++)
{
System.out.print(a1[i] + " ");    
}
System.out.println();
result = obj.findOddOccurrence(a1, size);

System.out.println("The number whose occurrence is odd is: " + result);

}
}

Output:

In the following input array: 
7 4 5 4 5 7 5 9 8 9 6 8 6 
The number whose occurrence is odd is: 5

In the following input array: 
4 3 9 3 4 9 4 7 4 7 4 
The number whose occurrence is odd is: 4

Time Complexity: The above program uses three loops. However, those loops are not nested. Therefore, the time complexity is O(n), where n is the total number of elements present in the input array.

Space Complexity: The above program uses some extra space. We see the usage of an array for storing the frequency of occurrence of elements. The space complexity of the above program is O(maxElement), where maxElement is the maximum element found in the input array.

The downside of this approach is the unused space in the array that stores the frequency. For example: for the array {7, 4, 5, 4, 5, 7, 5, 9, 8, 9, 6, 8, 6} the memory will be allocated for 10 elements in the array storeFreq[]. However, only storeFreq[4], storeFreq[5], storeFreq[6], storeFreq[7], storeFreq[8], and storeFreq[9] will be used. Thus, the space allocated for storeFreq[0], storeFreq[1], storeFreq[3], and many more goes in vain. The condition becomes, even more, worse if we get the input as {1000, 1, 1000}. In this case, we have to allocate the memory for the 1001 elements, out of which only memory of 2 elements (one for 1000 and another for 1) will be used. The rest of the other memory allocation is useless. To avoid this wastage of memory, we should be using a hash map.

Finding Odd Occurrence of a Number Using HashMap

We can also use a hash map to store the frequency of the occurrence of the elements. After that, we can check the numbers whose frequency is odd. The following program illustrates the same.

FileName: OddOccurrence2.java

// important import statement
import java.util.HashMap;

public class OddOccurrence2
{

public int findOddOccurrence(int a[], int size)
{
 
// In the hash map, key will be the element and value will be the 
// frequency of occurrence of the elements present in the input array.

// instantiating hash map
HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>(); 
  
// For every number compute the sum of digits
// starting from 1 to n
for (int y = 0; y < size; y++)
{

if(hm.containsKey(a[y]))
{
int countFreq = hm.get(a[y]);
    
// If the element is present in the hash map then
// increase the count of frquency of the occurrence of that element by 1.
hm.put(a[y], countFreq + 1); 
}
else
{
// if the element is not present in the hash map then put
// the element into the hash map and initialize the frequency  
// count to one.
hm.put(a[y], 1);
}
}

// looking for the odd occurrence of each of the element present
// in the hash map 
for(Integer i :hm.keySet())
{
    if(hm.get(i) % 2 != 0)
    {
        return i;
    }
}

return -1;

}

      
// main method
public static void main(String argvs[])
{

// creating an object of the class OddOccurrence2
OddOccurrence2 obj = new OddOccurrence2();

// input array
int a[] = {7, 4, 5, 4, 5, 7, 5, 9, 8, 9, 6, 8, 6};

// computing the size of the array
int size = a.length;


// displaying the result
System.out.println("In the following input array: ");

for(int i = 0; i < a.length; i++)
{
System.out.print(a[i] + " ");    
}
System.out.println();
int result = obj.findOddOccurrence(a, size);

System.out.println("The number whose occurrence is odd is: " + result);

System.out.println();

// input array
int a1[] = {4, 3, 9, 3, 4, 9, 4, 7, 4, 7, 4};

// computing the size of the array
size = a1.length;

// displaying the result
System.out.println("In the following input array: ");

for(int i = 0; i < a1.length; i++)
{
System.out.print(a1[i] + " ");    
}
System.out.println();
result = obj.findOddOccurrence(a1, size);

System.out.println("The number whose occurrence is odd is: " + result);

}
}

Output:

In the following input array: 
7 4 5 4 5 7 5 9 8 9 6 8 6 
The number whose occurrence is odd is: 5

In the following input array: 
4 3 9 3 4 9 4 7 4 7 4 
The number whose occurrence is odd is: 4

Time Complexity: The above program is using two loops. However, those loops are not nested. Therefore, the time complexity is O(n), where n is the total number elements present in the input array.

Space Complexity: The above program is using some extra space. Notice the usage of the hash map in the program for storing the elements and their frequency of occurrence. It is obvious that the hash map cannot store the elements more than the elements present in the input array. Therefore, the space complexity of the above program is O(n), where n is the total number of elements present in the input array.

Finding Odd Occurrence of a Number Using Bitwise XOR Operator

In this approach, we will use bitwise XOR (^) operation to find the odd occurrence of the number in the input array. The idea behind this approach is that XOR operation is commutative, i.e.,

7 ^ 4 ^ 5 ^ 4 ^ 5 ^ 7 ^ 5 ^ 9 ^ 8 ^ 9 ^ 6 ^ 8 ^ 6 is equal to
7 ^ 7 ^ 4 ^ 4 ^ 5 ^ 5 ^ 5 ^ 9 ^ 9 ^ 8 ^ 8 ^ 6 ^ 6 

All we have done is the rearrangement of numbers such that the same numbers are grouped together. Also, we know that the XOR of the any two same numbers is 0. Therefore,

7 ^ 7 = 0, 4 ^ 4 = 0, 5 ^ 5 ^ 5 = 0 ^ 5 = 5, 9 ^ 9 = 0, 8 ^ 8 = 0, 6 ^ 6 = 0

Thus, we have

7 ^ 7 ^ 4 ^ 4 ^ 5 ^ 5 ^ 5 ^ 9 ^ 9 ^ 8 ^ 8 ^ 6 ^ 6 = 0 ^ 0 ^ 5 ^ 0 ^ 0 ^ 0 = 5

The following program shows the same.

FileName: OddOccurrence3.java

public class OddOccurrence3
{

public int findOddOccurrence(int a[], int size)
{
 
int ans = 0;  

for (int y = 0; y < size; y++)
{
// performing the xor operation on the numbers
ans = ans ^ a[y];
}

return ans;

}

      
// main method
public static void main(String argvs[])
{

// creating an object of the class OddOccurrence3
OddOccurrence3 obj = new OddOccurrence3();

// input array
int a[] = {7, 4, 5, 4, 5, 7, 5, 9, 8, 9, 6, 8, 6};

// computing the size of the array
int size = a.length;


// displaying the result
System.out.println("In the following input array: ");

for(int i = 0; i < a.length; i++)
{
System.out.print(a[i] + " ");    
}
System.out.println();
int result = obj.findOddOccurrence(a, size);

System.out.println("The number whose occurrence is odd is: " + result);

System.out.println();

// input array
int a1[] = {4, 3, 9, 3, 4, 9, 4, 7, 4, 7, 4};

// computing the size of the array
size = a1.length;

// displaying the result
System.out.println("In the following input array: ");

for(int i = 0; i < a1.length; i++)
{
System.out.print(a1[i] + " ");    
}
System.out.println();
result = obj.findOddOccurrence(a1, size);

System.out.println("The number whose occurrence is odd is: " + result);

}
}

Output:

In the following input array: 
7 4 5 4 5 7 5 9 8 9 6 8 6 
The number whose occurrence is odd is: 5

In the following input array: 
4 3 9 3 4 9 4 7 4 7 4 
The number whose occurrence is odd is: 4

Time Complexity: The above program uses only one loop. Therefore, the time complexity is O(n), where n is the total number of elements present in the input array.

Space Complexity: The above program is not using any extra space. Therefore, the space complexity of the above program is O(1).

Next TopicJava Indentation

← prev next →