Find duplicate elements in an array

Last Updated : 19 Dec, 2024

Given an array of n integers. The task is to find all elements that have more than one occurrences. The output should only be one occurrence of a number irrespective of the number of occurrences in the input array.

Examples:

Input: {2, 10, 10, 100, 2, 10, 11, 2, 11, 2}
Output: {2, 10, 11}
Input: {5, 40, 1, 40, 100000, 1, 5, 1}
Output: {5, 40, 1}

Note: Duplicate elements can be printed in any order.

Naive Approach - O(n^2) Time and O(1) Space

The idea is to use a nested loop and for each element check if the element is present in the array more than once or not. If present, then check if it is already added to the result. If not, then add to the result.

Below is the implementation of the above approach:

C++

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

vector<int> findDuplicates(vector<int>& arr) {
    vector<int> res;

    for (int i = 0; i < arr.size() - 1; i++) {
        for (int j = i + 1; j < arr.size(); j++) {
            if (arr[i] == arr[j]) {
              
                // Check if the duplicate element is already in res
                auto it = find(res.begin(), res.end(), arr[i]);

                if (it == res.end()) {
                  
                    // Add the element to res if not already present
                    res.push_back(arr[i]);
                }
              
              	// Move to the next element in arr
                break; 
            }
        }
    }
    return res;
}

int main()
{
    vector<int> arr = {12, 11, 40, 12, 5, 6, 5, 12, 11};
    vector<int> duplicates = findDuplicates(arr);
    for (int i = 0; i < duplicates.size(); i++)
        cout << duplicates[i] << " ";    
    return 0;
}

Java

import java.util.ArrayList;
import java.util.List;

class GfG {
    static List<Integer> findDuplicates(int[] arr) {
        List<Integer> res = new ArrayList<>();

        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] == arr[j]) {
                  
                    // Check if the duplicate element is already in res
                    if (!res.contains(arr[i])) {
                        res.add(arr[i]);
                    }
                    break; 
                }
            }
        }

        return res;
    }

    public static void main(String[] args) {
        int[] arr = {12, 11, 40, 12, 5, 6, 5, 12, 11};
        List<Integer> duplicates = findDuplicates(arr);        
        for (int x : duplicates) {
            System.out.print(x + " ");
        }
    }
}

Python

def findDuplicates(arr):
    res = []

    for i in range(len(arr) - 1):
        for j in range(i + 1, len(arr)):
            if arr[i] == arr[j]:
              
                # Check if the duplicate element is already in res
                if arr[i] not in res:
                    res.append(arr[i])
                break  

    return res

# Driver code
if __name__ == "__main__":
    arr = [12, 11, 40, 12, 5, 6, 5, 12, 11]
    duplicates = findDuplicates(arr)
    for x in duplicates:
        print(x, end=' ')

using System;
using System.Collections.Generic;

class GfG {
    static List<int> findDuplicates(int[] arr) {
        List<int> res = new List<int>();

        for (int i = 0; i < arr.Length - 1; i++) {
            for (int j = i + 1; j < arr.Length; j++) {
                if (arr[i] == arr[j]) {
                    
                    // Check if the duplicate element is already in res
                    if (!res.Contains(arr[i])) {
                        
                        // Add the element to res if not already present
                        res.Add(arr[i]);
                    }
                    
                  	// Move to the next element in arr
                    break; 
                }
            }
        }

        return res;
    }

    static void Main() {
        int[] arr = {12, 11, 40, 12, 5, 6, 5, 12, 11};
        List<int> duplicates = findDuplicates(arr);
        for (int i = 0; i < duplicates.Count; i++) {
            Console.Write(duplicates[i] + " ");
        }
    }
}

JavaScript

function findDuplicates(arr) {
    let res = [];

    for (let i = 0; i < arr.length - 1; i++) {
        for (let j = i + 1; j < arr.length; j++) {
            if (arr[i] === arr[j]) {
                
                // Check if the duplicate element is already in res
                if (!res.includes(arr[i])) {
                    
                    // Add the element to res if not already present
                    res.push(arr[i]);
                }
                
                // Move to the next element in arr
                break; 
            }
        }
    }

    return res;
}

const arr = [12, 11, 40, 12, 5, 6, 5, 12, 11];
const duplicates = findDuplicates(arr);
for (let i = 0; i < duplicates.length; i++) {
    console.log(duplicates[i] + " ");
}

Output

12 11 5

Better Approach - Use Sorting and Binary Search - O(n Log n) Time and O(1) Space

Sort the array.
For every element, find indexes of its first and last occurrences using binary search.
If both indexes are same, then this element is having only one occurrence, so we ignore this element.
Else, we add this element to result and move the index to last index of this element plus 1.

C++

// C++ program to find the duplicate elements using Binary Search

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

vector<int> findDuplicates(vector<int>& arr) {   
    sort(arr.begin(), arr.end());  
    vector<int> res;  

    int i = 0;
    while (i < arr.size()) { 
      
        // Index of first and last occurrence of arr[i]
        // using binary search
        int first = lower_bound(arr.begin(), arr.end(), arr[i]) - arr.begin();
        int last = upper_bound(arr.begin(), arr.end(), arr[i]) - arr.begin() - 1;
        
        // If the element occurs more than once, add it to res
        if (last > first) {  
            res.push_back(arr[i]);  
        }
      
        // Update i to the last index 
        // of the current element
        i = last + 1;
    }
    return res;
}

int main() {   
    vector<int> arr = {12, 11, 40, 12, 5, 6, 5, 12, 11};   
    vector<int> res = findDuplicates(arr); 
    for (int i = 0; i < res.size(); i++) 
        cout << res[i] << " ";  
    return 0;
}

Java

// Java program to find the duplicate elements using Binary Search

import java.util.*;

class GfG {
    
    // Returns index of the first occurrence of target
    static int lowerBound(int[] arr, int target) {
        int low = 0, high = arr.length;
        while (low < high) {
            int mid = (low + high) / 2;
            if (arr[mid] < target) 
                low = mid + 1;
          	else 
                high = mid;
        }
        return low; 
    }

    // Returns index just past the last occurrence of target
    static int upperBound(int[] arr, int target) {
        int low = 0, high = arr.length;
        while (low < high) {
            int mid = (low + high) / 2;
            if (arr[mid] <= target) 
                low = mid + 1;
          	else 
                high = mid;
        }
        return low; 
    }

    // Function to return elements that occur in arr more than once
    static List<Integer> findDuplicates(int[] arr) {   
        Arrays.sort(arr);  
        List<Integer> res = new ArrayList<>();  

        int i = 0;
        while (i < arr.length) { 
            int first = lowerBound(arr, arr[i]);
            int last = upperBound(arr, arr[i]) - 1;

            // If the element occurs more than once, add it to res
            if (last > first) {  
                res.add(arr[i]);  
            }
            
            // Update i to the last index of the current element
            i = last + 1;
        }
        return res;
    }

    public static void main(String[] args) {   
        int[] arr = {12, 11, 40, 12, 5, 6, 5, 12, 11};   
        List<Integer> res = findDuplicates(arr);         
        for (int x : res) {
            System.out.print(x + " ");  
        }
    }
}

Python

# Python program to find the duplicate elements using 
# Binary Search

# Index of the first occurrence of target
def lowerBound(arr, target):
    low, high = 0, len(arr)
    while low < high:
        mid = (low + high) // 2
        if arr[mid] < target:
            low = mid + 1
        else:
            high = mid
    return low  

# Index just past the last occurrence of target
def upperBound(arr, target):
    low, high = 0, len(arr)
    while low < high:
        mid = (low + high) // 2
        if arr[mid] <= target:
            low = mid + 1
        else:
            high = mid
    return low

def findDuplicates(arr):
    arr.sort()
    res = []  

    i = 0
    while i < len(arr):
        first = lowerBound(arr, arr[i])
        last = upperBound(arr, arr[i]) - 1

        # If the element occurs more than once, add it to res
        if last > first:
            res.append(arr[i])

        # Update i to the last index of the current element
        i = last + 1
    return res

# Driver code
if __name__ == "__main__":
    arr = [12, 11, 40, 12, 5, 6, 5, 12, 11]
    res = findDuplicates(arr)
    for x in res:
        print(x, end=' ')

// C# program to find the duplicate elements using 
// Binary Search

using System;
using System.Collections.Generic;

class GfG {
    static int lowerBound(int[] arr, int target) {
        int left = 0;
        int right = arr.Length;

        while (left < right) {
            int mid = left + (right - left) / 2;

            if (arr[mid] < target)
                left = mid + 1;
            else
                right = mid;
        }

        return left;
    }

    static int upperBound(int[] arr, int target) {
        int left = 0;
        int right = arr.Length;

        while (left < right) {
            int mid = left + (right - left) / 2;

            if (arr[mid] <= target)
                left = mid + 1;
            else
                right = mid;
        }

        return left;
    }

    static List<int> findDuplicates(int[] arr) {
        Array.Sort(arr);

        List<int> duplicates = new List<int>();

        for (int i = 0; i < arr.Length; i++) {
            int lower = lowerBound(arr, arr[i]);
            int upper = upperBound(arr, arr[i]);

            if (upper - lower > 1)
                duplicates.Add(arr[i]);

            // Skip to the next unique element
            i = upper - 1;
        }

        return duplicates;
    }

    static void Main() {
        int[] arr = { 12, 11, 40, 12, 5, 6, 5, 12, 11 };
        List<int> duplicates = findDuplicates(arr);

        foreach (int num in duplicates)
            Console.Write(num + " ");
    }
}

JavaScript

// JavaScript program to find the duplicate elements using 
// Binary Search

function findDuplicates(arr) {   
    arr.sort();  
    let res = [];  

    let i = 0;
    while (i < arr.length) { 
        
        // Index of first and last occurrence of arr[i]
        // using binary search
        let first = arr.indexOf(arr[i]);
        let last = arr.lastIndexOf(arr[i]);
        
        // If the element occurs more than once, add it to res
        if (last > first) {  
            res.push(arr[i]);  
        }
      
        // Update i to the last index 
        // of the current element
        i = last + 1;
    }
    return res;
}

const arr = [12, 11, 40, 12, 5, 6, 5, 12, 11];   
const res = findDuplicates(arr); 
for (let i = 0; i < res.length; i++) 
    console.log(res[i] + " ");

Output

5 11 12

Expected Approach - O(n) Time and O(n) Space

We use hashing. Count frequency of occurrence of each element and the elements with frequency more than 1 is printed. unordered map is used as range of integers is not known. For Python, Use Dictionary to store number as key and it's frequency as value. Dictionary can be used as range of integers is not known.

C++

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

vector<int> findDuplicates(vector<int>& arr) {
  
    // Find frequency of every element
    unordered_map<int, int> freq;
    for (int x : arr)
        freq[x]++;

    // Move all those elements to resul that
    // have frequency more than 1.
    vector<int> res;
    for (auto& entry : freq) {
        if (entry.second > 1)
            res.push_back(entry.first);
    }

    return res;
}

int main() {
    vector<int> arr = {12, 11, 40, 12, 5, 6, 5, 12, 11};
    vector<int> res = findDuplicates(arr);
    for (int num : res) {
        cout << num << " ";
    }
    return 0;
}

Java

import java.util.*;

class GfG {
    static List<Integer> findDuplicates(List<Integer> arr) {
      
        // Find frequency of every element
        Map<Integer, Integer> freq = new HashMap<>();
        for (int x : arr) {
            freq.put(x, freq.getOrDefault(x, 0) + 1);
        }

        // Move all those elements to result that
        // have frequency more than 1.
        List<Integer> res = new ArrayList<>();
        for (Map.Entry<Integer, Integer> entry : freq.entrySet()) {
            if (entry.getValue() > 1) {
                res.add(entry.getKey());
            }
        }

        return res;
    }

    public static void main(String[] args) {
        List<Integer> arr = Arrays.asList(12, 11, 40, 12, 5, 6, 5, 12, 11);
        List<Integer> res = findDuplicates(arr);
        for (int x : res) {
            System.out.print(x + " ");
        }
    }
}

Python

from collections import defaultdict

def findDuplicates(arr):
  
    # Find frequency of every element
    freq = defaultdict(int)
    for x in arr:
        freq[x] += 1

    # Move all those elements to result that
    # have frequency more than 1.
    res = [x for x in freq if freq[x] > 1]
    
    return res

if __name__ == "__main__":
    arr = [12, 11, 40, 12, 5, 6, 5, 12, 11]
    res = findDuplicates(arr)
    for x in res:
        print(x, end=' ')

using System;
using System.Collections.Generic;
using System.Linq;

class GfG {
    static List<int> findDuplicates(List<int> arr) {
  
        // Find frequency of every element
        var freq = arr.GroupBy(x => x).ToDictionary(g => g.Key, g => g.Count());

        // Move all those elements to resul that
        // have frequency more than 1.
        var res = freq.Where(entry => entry.Value > 1).Select(entry => entry.Key).ToList();

        return res;
    }

    static void Main(string[] args) {
        List<int> arr = new List<int> { 12, 11, 40, 12, 5, 6, 5, 12, 11 };
        List<int> res = findDuplicates(arr);
        foreach (int num in res) {
            Console.Write(num + " ");
        }
    }
}

JavaScript

function findDuplicates(arr) {
  
    // Find frequency of every element
    let freq = {};
    for (let x of arr)
        freq[x] = (freq[x] || 0) + 1;

    // Move all those elements to resul that
    // have frequency more than 1.
    let res = [];
    for (let entry in freq) {
        if (freq[entry] > 1)
            res.push(parseInt(entry));
    }
    return res;
}

let arr = [12, 11, 40, 12, 5, 6, 5, 12, 11];
let res = findDuplicates(arr);
for (let num of res) {
    console.log(num + " ");
}

Output

12 11 5

Find lost element from a duplicated array

Ayush Jauhari

Improve

Article Tags :

Practice Tags :

Find duplicate elements in an array

Naive Approach - O(n^2) Time and O(1) Space

Better Approach - Use Sorting and Binary Search - O(n Log n) Time and O(1) Space

Expected Approach - O(n) Time and O(n) Space

Similar Reads

Thank You!

What kind of Experience do you want to share?