Find the odd appearing element in O(Log n) time

Single Element in a Sorted Array

Last Updated : 24 Sep, 2024

Try it on GfG Practice

Given a sorted array in which all elements appear twice and one element appears only once, the task is to find the element that appears once.

Examples:

Input: arr[] = {1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8}
Output: 4
Explanation: All numbers except 4 occur twice in the array.

Input: arr[] = {1, 1, 3, 3, 4, 4, 5, 5, 7, 7, 8}
Output: 8
Explanation: All numbers except 8 occur twice in the array.

[Naive Approach 1] By comparing adjacent elements – O(n) Time and O(1) Space:

The single element must appear at an odd position (or even index) because every other element appears twice.
One by one check all odd postilions (or even indexes) and if we find an element which is not same as next, we return the element.

Below is the implementation of the above approach.

C++

#include <bits/stdc++.h>
using namespace std;

int single(const vector<int>& arr) {
  
    int n = arr.size();
 
   // Since every other element appears twice,
   // the single element must be at an odd
   // position
   for (int i = 0; i < n - 1; i += 2) {
        if (arr[i] != arr[i + 1]) {
            return arr[i];
        }
    }
  
    // If no element found, the 
    // single element must be 
    // the last one
    return arr[n - 1];  
}

int main() {
    vector<int> arr = {1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8};
    cout << single(arr);
    return 0;
}

C

#include <stdio.h>

int single(int arr[], int n) {
    
    // Since every other element appears twice,
    // the single element must be at an odd
    // position
    for (int i = 0; i < n - 1; i += 2) {
        if (arr[i] != arr[i + 1]) {
            return arr[i];
        }
    }
  
    // If no element found, the 
    // single element must be 
    // the last one
    return arr[n - 1];  
}

int main() {
    int arr[] = {1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("%d", single(arr, n));
    return 0;
}

Java

class GfG {

    static int single(int[] arr) {
        int n = arr.length;

        // Since every other element appears twice,
        // the single element must be at an odd
        // position
        for (int i = 0; i < n - 1; i += 2) {
            if (arr[i] != arr[i + 1]) {
                return arr[i];
            }
        }

        // If no element found, the 
        // single element must be 
        // the last one
        return arr[n - 1];
    }

    public static void main(String[] args) {
        int[] arr = {1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8};
        System.out.println(single(arr));
    }
}

Python

def single(arr):
    n = len(arr)

    # Since every other element appears twice,
    # the single element must be at an odd
    # position
    for i in range(0, n - 1, 2):
        if arr[i] != arr[i + 1]:
            return arr[i]

    # If no element found, the 
    # single element must be 
    # the last one
    return arr[n - 1]

# Driver code
arr = [1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8]
print(single(arr))

C#

using System;

class GfG
{
    static int single(int[] arr) {
        int n = arr.Length;

        // Since every other element appears twice,
        // the single element must be at an odd
        // position
        for (int i = 0; i < n - 1; i += 2) {
            if (arr[i] != arr[i + 1]) {
                return arr[i];
            }
        }

        // If no element found, the 
        // single element must be 
        // the last one
        return arr[n - 1];
    }

    static void Main() {
        int[] arr = {1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8};
        Console.WriteLine(single(arr));
    }
}

JavaScript

function single(arr) {
    const n = arr.length;

    // Since every other element appears twice,
    // the single element must be at an odd
    // position
    for (let i = 0; i < n - 1; i += 2) {
        if (arr[i] !== arr[i + 1]) {
            return arr[i];
        }
    }

    // If no element found, the 
    // single element must be 
    // the last one
    return arr[n - 1];
}

// Driver code
const arr = [1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8];
console.log(single(arr));

Output

Time Complexity: O(n)
Auxiliary Space: O(1), since no extra space has been taken.

[Naive Approach 2] Using Bitwise XOR – O(n) Time and O(1) Space:

We can use the properties of XOR (a ^ a = 0 & a ^ 0 = a) to find the element that occurs once. The idea is to find the XOR of the complete array, so all the elements which occur twice will have their XOR = 0 and the XOR of the array will be the required answer.

C++

#include <bits/stdc++.h>
using namespace std;

// A XOR based function to find
// the element that appears only once
int single(vector<int>& arr)
{
    int XOR = 0;
    for (int i = 0; i < arr.size(); i++) {
        XOR ^= arr[i];
    }
    return XOR;
}

int main()
{
    vector<int> arr = { 1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8};
    cout << single(arr) << "\n";
    return 0;
}

C

#include <stdio.h>

// A XOR based function to find
// the element that appears only once
int single(int arr[], int n)
{
    int XOR = 0;
    for (int i = 0; i < n; i++) {
        XOR ^= arr[i];
    }
    return XOR;
}

int main()
{
    int arr[] = {1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("%d\n", single(arr, n));
    return 0;
}

Java

class GfG {

    // A XOR based function to find
    // the element that appears only once
    static int single(int[] arr) {
        int XOR = 0;
        for (int i = 0; i < arr.length; i++) {
            XOR ^= arr[i];
        }
        return XOR;
    }

    public static void main(String[] args) {
        int[] arr = {1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8};
        System.out.println(single(arr));
    }
}

Python

# A XOR based function to find
# the element that appears only once
def single(arr):
    XOR = 0
    for i in arr:
        XOR ^= i
    return XOR

# Driver code
arr = [1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8]
print(single(arr))

C#

using System;

class GfG
{
    // A XOR based function to find
    // the element that appears only once
    static int single(int[] arr) {
        int XOR = 0;
        for (int i = 0; i < arr.Length; i++) {
            XOR ^= arr[i];
        }
        return XOR;
    }

    static void Main() {
        int[] arr = {1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8};
        Console.WriteLine(single(arr));
    }
}

JavaScript

// A XOR based function to find
// the element that appears only once
function single(arr) {
    let XOR = 0;
    for (let i = 0; i < arr.length; i++) {
        XOR ^= arr[i];
    }
    return XOR;
}

// Driver code
const arr = [1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8];
console.log(single(arr));

Output

Time Complexity: O(n)
Auxiliary Space: O(1)

[Expected Approach] Using Binary Search – O(log n) Time and O(1) Space:

The idea is to use Binary Search. Below is an observation on the input array.
All elements before the element that occurs once have the first occurrence at even index (0, 2, ..) and the next occurrence at odd index (1, 3, …). And all elements after the element that occurs once have the first occurrence at an odd index and the next occurrence at an even index.

Find the middle index, say ‘mid‘. If mid is odd, then reduce it by 1 to make it even
If ‘arr[mid] and arr[mid+1] are same, then the single element must be on the right side
Else single element must be on the left side.

Below is the implementation based on the above idea:

C++

#include <bits/stdc++.h>
using namespace std;

int single(vector<int>& arr) {
    int n = arr.size();
    int lo = 0, hi = n - 1;
    
    while (lo < hi) {
        int mid = lo + (hi - lo) / 2;
        
        // Ensure mid is even
        if (mid % 2 == 1)
            mid--;
        
        // If repeating element is at even position, 
        // then single element must be on the right side
        if (arr[mid] == arr[mid + 1]) {
            lo = mid + 2;
          
        // Else single element must be on the left  
        } else {
            hi = mid;
        }
    }
    
    return arr[lo];
}

int main() {
    vector<int> arr = {1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8};
    cout << single(arr) << "\n";
    return 0;
}

C

#include <stdio.h>

int single(int arr[], int n) {
    int lo = 0, hi = n - 1;
    
    while (lo < hi) {
        int mid = lo + (hi - lo) / 2;
        
        // Ensure mid is even
        if (mid % 2 == 1)
            mid--;
        
        // If repeating element is at even position, 
        // then single element must be on the right side
        if (arr[mid] == arr[mid + 1]) {
            lo = mid + 2;
        } 
      
        // Else single element must be on the left  
        else {
            hi = mid;
        }
    }
    
    return arr[lo];
}

int main() {
    int arr[] = {1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("%d\n", single(arr, n));
    return 0;
}

Java

class GfG {

    static int single(int[] arr) {
        int lo = 0, hi = arr.length - 1;
        
        while (lo < hi) {
            int mid = lo + (hi - lo) / 2;
            
            // Ensure mid is even
            if (mid % 2 == 1)
                mid--;
            
            // If repeating element is at even position, 
            // then single element must be on the right side
            if (arr[mid] == arr[mid + 1]) {
                lo = mid + 2;
            } 
          
            // Else single element must be on the left  
            else {
                hi = mid;
            }
        }
        
        return arr[lo];
    }

    public static void main(String[] args) {
        int[] arr = {1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8};
        System.out.println(single(arr));
    }
}

Python

def single(arr):
    lo, hi = 0, len(arr) - 1
    
    while lo < hi:
        mid = lo + (hi - lo) // 2
        
        # Ensure mid is even
        if mid % 2 == 1:
            mid -= 1
        
        # If repeating element is at even position, 
        # then single element must be on the right side
        if arr[mid] == arr[mid + 1]:
            lo = mid + 2
            
        # Else single element must be on the left  
        else:
            hi = mid

    return arr[lo]

# Driver code
arr = [1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8]
print(single(arr))

C#

using System;

class GfG
{
    static int single(int[] arr) {
        int lo = 0, hi = arr.Length - 1;
        
        while (lo < hi) {
            int mid = lo + (hi - lo) / 2;
            
            // Ensure mid is even
            if (mid % 2 == 1)
                mid--;
            
            // If repeating element is at even position, 
            // then single element must be on the right side
            if (arr[mid] == arr[mid + 1]) {
                lo = mid + 2;
            } 
          
            // Else single element must be on the left  
            else {
                hi = mid;
            }
        }
        
        return arr[lo];
    }

    static void Main() {
        int[] arr = {1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8};
        Console.WriteLine(single(arr));
    }
}

JavaScript

function single(arr) {
    let lo = 0, hi = arr.length - 1;
    
    while (lo < hi) {
        let mid = lo + Math.floor((hi - lo) / 2);
        
        // Ensure mid is even
        if (mid % 2 === 1)
            mid--;
        
        // If repeating element is at even position, 
        // then single element must be on the right side
        if (arr[mid] === arr[mid + 1]) {
            lo = mid + 2;
        }
        
        // Else single element must be on the left  
        else {
            hi = mid;
        }
    }
    
    return arr[lo];
}

// Driver code
const arr = [1, 1, 3, 3, 4, 5, 5, 7, 7, 8, 8];
console.log(single(arr));

Output

Time Complexity: O(Log n), where n is the number of elements in the array.
Auxiliary Space: O(1)

Find the odd appearing element in O(Log n) time

M

Mehboob Elahi

News

Improve

Article Tags :

Practice Tags :

Similar Reads

Second Largest Element in an Array

Given an array of positive integers arr[] of size n, the task is to find second largest distinct element in the array. Note: If the second largest element does not exist, return -1. Examples: Input: arr[] = [12, 35, 1, 10, 34, 1]Output: 34Explanation: The largest element of the array is 35 and the s

Kâ€™th Smallest Element in Unsorted Array

Given an array arr[] of N distinct elements and a number K, where K is smaller than the size of the array. Find the K'th smallest element in the given array. Examples: Input: arr[] = {7, 10, 4, 3, 20, 15}, K = 3 Output: 7 Input: arr[] = {7, 10, 4, 3, 20, 15}, K = 4 Output: 10 Table of Content [Naive

Sorting all array elements except one

Given an array, a positive integer, sort the array in ascending order such that the element at index K in the unsorted array stays unmoved and all other elements are sorted. Examples: Input : arr[] = {10, 4, 11, 7, 6, 20} k = 2; Output : arr[] = {4, 6, 11, 7, 10, 20} Input : arr[] = {30, 20, 10} k =

Print all unique elements present in a sorted array

Given a sorted array arr[] of size N, the task is to print all the unique elements in the array. An array element is said to be unique if the frequency of that element in the array is 1. Examples: Input: arr[ ] = {1, 1, 2, 2, 3, 4, 5, 5}Output: 3 4Explanation: Since 1, 2, 5 are occurring more than o

Peak Element in Array

Given an array arr[] where no two adjacent elements are same, find the index of a peak element. An element is considered to be a peak element if it is strictly greater than its adjacent elements. If there are multiple peak elements, return the index of any one of them. Note: Consider the element bef

Remove elements to make array sorted

Given an array of integers, the task is to remove elements from the array to make the array sorted. That is, remove the elements which do not follow an increasing order. Examples: Input: arr[] = {1, 2, 4, 3, 5, 7, 8, 6, 9, 10} Output: 1 2 4 5 7 8 9 10 Input: arr[] = {10, 12, 9, 5, 2, 13, 14} Output:

Print sorted distinct elements of array

Given an array that might contain duplicates, print all distinct elements in sorted order. Examples: Input : 1, 3, 2, 2, 1Output : 1 2 3Input : 1, 1, 1, 2, 2, 3Output : 1 2 3The simple Solution is to sort the array first, then traverse the array and print only first occurrences of elements. Algorith

Sort a K-Increasing-Decreasing Array

Given a K-increasing-decreasing array arr[], the task is to sort the given array. An array is said to be K-increasing-decreasing if elements repeatedly increase upto a certain index after which they decrease, then again increase, a total of K times. The diagram below shows a 4-increasing-decreasing

Merge 3 Sorted Arrays

Given 3 arrays A[], B[], and C[] that are sorted in ascending order, the task is to merge them together in ascending order and output the array D[]. Examples: Input: A = [1, 2, 3, 4, 5], B = [2, 3, 4], C = [4, 5, 6, 7]Output : D = [1, 2, 2, 3, 3, 4, 4, 4, 5, 5, 6, 7] Input: A = [1, 2, 3, 5], B = [6,

Find the Kth occurrence of an element in a sorted Array

Given a sorted array arr[] of size N, an integer X, and a positive integer K, the task is to find the index of Kth occurrence of X in the given array. Examples: Input: N = 10, arr[] = [1, 2, 3, 3, 4, 5, 5, 5, 5, 5], X = 5, K = 2Output: Starting index of the array is '0' Second occurrence of 5 is at