Find duplicates in O(n) time and O(1) extra space

Find duplicates in O(n) time and O(1) extra space | Set 1

Difficulty Level : Medium
Last Updated : 08 Apr, 2021

Given an array of n elements that contains elements from 0 to n-1, with any of these numbers appearing any number of times. Find these repeating numbers in O(n) and using only constant memory space.

Example:

Input : n = 7 and array[] = {1, 2, 3, 6, 3, 6, 1}
Output: 1, 3, 6

Explanation: The numbers 1 , 3 and 6 appears more
than once in the array.

Input : n = 5 and array[] = {1, 2, 3, 4 ,3}
Output: 3

Explanation: The number 3 appears more than once
in the array.

This problem is an extended version of the following problem.
Find the two repeating elements in a given array
Method 1 and Method 2 of the above link are not applicable as the question says O(n) time complexity and O(1) constant space. Also, Method 3 and Method 4 cannot be applied here because there can be more than 2 repeating elements in this problem. Method 5 can be extended to work for this problem. Below is the solution that is similar to Method 5.

Solution 1:

Approach:The elements in the array is from 0 to n-1 and all of them are positive. So to find out the duplicate elements, a HashMap is required, but the question is to solve the problem in constant space. There is a catch, the array is of length n and the elements are from 0 to n-1 (n elements). The array can be used as a HashMap.
Problem in the below approach. This approach only works for arrays having at most 2 duplicate elements i.e It will not work if the array contains more than 2 duplicates of an element. For example: {1, 6, 3, 1, 3, 6, 6} it will give output as : 1 3 6 6.
Note: The above program doesn’t handle 0 cases (If 0 is present in array). The program can be easily modified to handle that also. It is not handled to keep the code simple.

In other approaches below, solutions are discussed that prints repeating elements only once.
Algorithm:

Traverse the array from start to end.
For every element,take its absolute value and if the abs(array[i])‘th element is positive, the element has not encountered before, else if negative the element has been encountered before print the absolute value of the current element.

Implementation:

C++

// C++ code to find
// duplicates in O(n) time
#include <bits/stdc++.h>
using namespace std;
  
// Function to print duplicates
void printRepeating(int arr[], int size)
{
    int i;
    cout << "The repeating elements are:" << endl;
    for (i = 0; i < size; i++) {
        if (arr[abs(arr[i])] >= 0)
            arr[abs(arr[i])] = -arr[abs(arr[i])];
        else
            cout << abs(arr[i]) << " ";
    }
}
  
// Driver Code
int main()
{
    int arr[] = { 1, 2, 3, 1, 3, 6, 6 };
    int arr_size = sizeof(arr) / sizeof(arr[0]);
    printRepeating(arr, arr_size);
    return 0;
}
  
// This code is contributed
// by Akanksha Rai

C

// C code to find
// duplicates in O(n) time
#include <stdio.h>
#include <stdlib.h>
  
// Function to print duplicates
void printRepeating(int arr[], int size)
{
    int i;
    printf("The repeating elements are: \n");
    for (i = 0; i < size; i++) {
        if (arr[abs(arr[i])] >= 0)
            arr[abs(arr[i])] = -arr[abs(arr[i])];
        else
            printf(" %d ", abs(arr[i]));
    }
}
  
// Driver Code
int main()
{
    int arr[] = { 1, 2, 3, 1, 3, 6, 6 };
    int arr_size = sizeof(arr) / sizeof(arr[0]);
    printRepeating(arr, arr_size);
    getchar();
    return 0;
}

Java

// Java code to find
// duplicates in O(n) time
  
class FindDuplicate {
    // Function to print duplicates
    void printRepeating(int arr[], int size)
    {
        int i;
        System.out.println("The repeating elements are : ");
          
        for (i = 0; i < size; i++) {
            int j = Math.abs(arr[i]);
            if (arr[j] >= 0)
                arr[j] = -arr[j];
            else
                System.out.print(j + " ");
        }
    }
  
    // Driver code
    public static void main(String[] args)
    {
        FindDuplicate duplicate = new FindDuplicate();
        int arr[] = { 1, 2, 3, 1, 3, 6, 6 };
        int arr_size = arr.length;
  
        duplicate.printRepeating(arr, arr_size);
    }
}
  
// This code has been contributed by Mayank Jaiswal

Python

# Python3 code to find
# duplicates in O(n) time
  
# Function to print duplicates
  
  
def printRepeating(arr, size):
  
    print("The repeating elements are: ")
  
    for i in range(0, size):
  
        if arr[abs(arr[i])] >= 0:
            arr[abs(arr[i])] = -arr[abs(arr[i])]
        else:
            print(abs(arr[i]), end=" ")
  
  
# Driver code
arr = [1, 2, 3, 1, 3, 6, 6]
arr_size = len(arr)
  
printRepeating(arr, arr_size)
  
# This code is contributed by Shreyanshi Arun.

C#

// C# code to find
// duplicates in O(n) time
using System;
  
class GFG {
    static void printRepeating(int[] arr, int size)
    {
        int i;
  
        Console.Write("The repeating" + 
                      " elements are : ");
  
        for (i = 0; i < size; i++) {
            int j = Math.Abs(arr[i]);
            if (arr[j] >= 0)
                arr[j] = -arr[j];
            else
                Console.Write(j + " ");
        }
    }
  
    // Driver code
    public static void Main()
    {
        int[] arr = { 1, 2, 3, 1, 3, 6, 6 };
        int arr_size = arr.Length;
  
        printRepeating(arr, arr_size);
    }
}
  
// This code is contributed by Sam007

PHP

<?php
// PHP program to Find duplicates in O(n) 
// time and O(1) extra space | Set 1
  
function printRepeating($arr, $size)
{
  
    echo "The repeating elements are: \n";
    for ($i = 0; $i < $size; $i++)
    {
        if ($arr[abs($arr[$i])] >= 0)
            $arr[abs($arr[$i])] = -$arr[abs($arr[$i])];
        else
            echo abs($arr[$i]) . " ";
    }
}
  
// Driver Code
$arr = array(1, 2, 3, 1, 3, 6, 6);
$arr_size = count($arr);
printRepeating($arr, $arr_size);
  
// This code is contributed by Sam007
?>

Javascript

<script>
// JavaScript code to find
// duplicates in O(n) time
  
// Function to print duplicates
function printRepeating(arr, size)
{
    let i;
    document.write("The repeating elements are:" + "<br>");
    for (i = 0; i < size; i++) {
        var abs_value = Math.abs(arr[i]);
        if (arr[abs_value] >= 0)
            arr[abs_value] = -arr[abs_value];
        else
            document.write(abs_value + " ");
    }
}
  
// Driver Code
    let arr = [ 1, 2, 3, 1, 3, 6, 6 ];
    let arr_size = arr.length;
    printRepeating(arr, arr_size);
  
// This code is contributed by Surbhi Tyagi.
  
</script>

Output:

The repeating elements are:
1  3  6

Complexity Analysis:

Time Complexity: O(n), only one traversal is needed, so time complexity is O(n)
Auxiliary Space: O(1), no extra space is required, so space complexity is constant.

Alternate Solution:

Approach: The basic idea is to use a HashMap to solve the problem. But there is a catch, the numbers in the array are from 0 to n-1, and the input array has length n. So, the input array can be used as a HashMap. While Traversing the array, if an element ‘a’ is encountered then increase the value of a%n‘th element by n. The frequency can be retrieved by dividing the a % n’th element by n.
Algorithm:
1. Traverse the given array from start to end.
2. For every element in the array increment the arr[i]%n‘th element by n.
3. Now traverse the array again and print all those indexes i for which arr[i]/n is greater than 1. Which guarantees that the number n has been added to that index
4. This approach works because all elements are in the range from 0 to n-1 and arr[i] would be greater than n only if a value “i” has appeared more than once.

Implementation:

C++

// C++ code to find
// duplicates in O(n) time
#include <bits/stdc++.h>
using namespace std;
  
int main()
{
  
    int numRay[] = { 0, 4, 3, 2, 7, 8, 2, 3, 1 };
    int arr_size = sizeof(numRay) / sizeof(numRay[0]);
    
    
    // count the frequency
    for (int i = 0; i < arr_size; i++) {
        numRay[numRay[i] % arr_size]
            = numRay[numRay[i] % arr_size] + arr_size;
    }
    cout << "The repeating elements are : " << endl;
    for (int i = 0; i < arr_size; i++) {
        if (numRay[i] >= arr_size * 2) {
            cout << i << " " << endl;
        }
    }
    return 0;
}
  
// This code is contributed by PrinciRaj1992

Java

// JAVA code to find
// duplicates in O(n) time
  
class Leet442 {
  
    public static void main(String args[])
    {
        int numRay[] = { 0, 4, 3, 2, 7, 8, 2, 3, 1 };
  
        for (int i = 0; i < numRay.length; i++) {
            numRay[numRay[i] % numRay.length]
                = numRay[numRay[i] % numRay.length]
                  + numRay.length;
        }
        System.out.println("The repeating elements are : ");
        for (int i = 0; i < numRay.length; i++) {
            if (numRay[i] >= numRay.length * 2) {
                System.out.println(i + " ");
            }
        }
    }
}

Python

# Python3 code to find duplicates in O(n) time
numRay = [0, 4, 3, 2, 7, 8, 2, 3, 1]
arr_size = len(numRay)
for i in range(arr_size):
  
    x = numRay[i] % arr_size
    numRay[x] = numRay[x] + arr_size
  
print("The repeating elements are : ")
for i in range(arr_size):
    if (numRay[i] >= arr_size*2):
        print(i, " ")
  
# This code is contributed by 29AjayKumar

C#

// C# code to find
// duplicates in O(n) time
using System;
class Leet442 
{
    public static void Main(String []args)
    {
        int []numRay = { 0, 4, 3, 2, 7, 8, 2, 3, 1 };
  
        for (int i = 0; i < numRay.Length; i++) 
        {
            numRay[numRay[i] % numRay.Length]
                = numRay[numRay[i] % numRay.Length]
                + numRay.Length;
        }
        Console.WriteLine("The repeating elements are : ");
        for (int i = 0; i < numRay.Length; i++) 
        {
            if (numRay[i] >= numRay.Length * 2) 
            {
                Console.WriteLine(i + " ");
            }
        }
    }
}
  
// This code is contributed by shivanisinghss2110

Javascript

<script>
    // Javascript code to find
    // duplicates in O(n) time
    let numRay = [ 0, 4, 3, 2, 7, 8, 2, 3, 1 ];
    let arr_size = numRay.length;
     
     
    // count the frequency
    for (let i = 0; i < arr_size; i++) {
        numRay[numRay[i] % arr_size]
            = numRay[numRay[i] % arr_size] + arr_size;
    }
    document.write("The repeating elements are : " + "</br>");
    for (let i = 0; i < arr_size; i++) {
        if (numRay[i] >= arr_size * 2) {
            document.write(i + " " + "</br>");
        }
    }
  
// This code is contributed by mukesh07.
</script>

Output:

The repeating elements are : 
2 
3

Complexity Analysis:

Time Complexity: O(n).
Only two traversals are needed. So the time complexity is O(n).
Auxiliary Space: O(1).
No extra space is needed, so the space complexity is constant.

My Personal Notes

Related Articles

C++

C

Java

Python

C#

PHP

Javascript

C++

Java

Python

C#

Javascript