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

Given an array of n elements which 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, 1, 3, 6, 6}
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.

Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

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.
Algorithm:
1. Traverse the array from start to end.
2. 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])); 
  } 
} 
  
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++) 
        { 
            if (arr[ Math.abs(arr[i])] >= 0) 
                arr[ Math.abs(arr[i])] = -arr[ Math.abs(arr[i])]; 
            else
                System.out.print(Math.abs(arr[i]) + " "); 
        }          
    }  
  
    // Driver program  
    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 

Python3

# 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++) 
        { 
            if (arr[ Math.Abs(arr[i])] >= 0) 
                arr[ Math.Abs(arr[i])] = 
                    -arr[ Math.Abs(arr[i])]; 
            else
                Console.Write(Math.Abs(arr[i]) + " "); 
        }          
    }  
  
    // Driver program  
    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 
?> 

Output:
```
The repeating elements are:
1  3  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.
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.

There is a problem in the above approach.
It prints the repeated number more than once. For example: {1, 6, 3, 1, 3, 6, 6} it will give output as : 1 3 6 6. In below set, another approach is discussed that prints repeating elements only once.

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]);  
    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

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): 
   
    numRay[numRay[i] % arr_size] = numRay[numRay[i] % arr_size] +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 

Output:
```
The repeating elements are : 
2 
3
```
Complexity Anlaysis:
- 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.

Duplicates in an array in O(n) and by using O(1) extra space | Set-2

Please write comments if you find the above codes/algorithms incorrect, or find better ways to solve the same problem.

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes

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

Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

C++

C

Java

Python3

C#

PHP

C++

Java

Python

Recommended Posts: