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

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.

For example, let n be 7 and array be {1, 2, 3, 1, 3, 6, 6}, the answer should be 1, 3 and 6.

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.

Algorithm:

traverse the list for i= 0 to n-1 elements
{
  check for sign of A[abs(A[i])] ;
  if positive then
     make it negative by   A[abs(A[i])]=-A[abs(A[i])];
  else  // i.e., A[abs(A[i])] is negative
     this   element (ith element of list) is a repetition
}

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 case (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.

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

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.

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

Another O(n) & O(1) code:

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] % 10] = numRay[numRay[i] % 10] + 10;
    }
    cout << "The repeating elements are : " << endl;
    for (int i = 0; i < arr_size; i++)
    {
        if (numRay[i] > 19)
        {
            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] % 10] = numRay[numRay[i] % 10] + 10;
        }
        System.out.println("The repeating elements are : ");
        for (int i = 0; i < numRay.length; i++) {
            if (numRay[i] > 19) {
                System.out.println(i + " ");
            }
        }
    }
}

Python3

# 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] % 10] = numRay[numRay[i] % 10] + 10;

print("The repeating elements are : ");
for i in range(arr_size):
    if (numRay[i] > 19):
        print(i, " ");

# This code is contributed by 29AjayKumar

C#

using System;

class GFG
{
    public static void Main(String []args)
    {
        int []numRay1 = {0, 4, 3, 2, 7, 8, 2, 3, 1};

        for(int i = 0; i < numRay1.Length; i++)
            numRay1[numRay1[i] % 10] = numRay1[numRay1[i] % 10] + 10;

        Console.WriteLine("The repeating elements are : ");

        for(int i = 0; i < numRay1.Length; i++)
            if(numRay1[i] > 19)
                Console.WriteLine(i + " ");
    }
}

// This code is contributed by Rajput-Ji

Output:

The repeating elements are : 
2 
3

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

Recommended Posts:

• Duplicates in an array in O(n) time and by using O(1) extra space | Set-3
• Find the maximum repeating number in O(n) time and O(1) extra space
• Duplicates in an array in O(n) and by using O(1) extra space | Set-2
• Rearrange positive and negative numbers in O(n) time and O(1) extra space
• Design a stack that supports getMin() in O(1) time and O(1) extra space
• Count frequencies of all elements in array in O(1) extra space and O(n) time
• Find duplicates in constant array with elements 0 to N-1 in O(1) space
• Find median of BST in O(n) time and O(1) space
• Rearrange an array so that arr[i] becomes arr[arr[i]] with O(1) extra space
• K'th smallest element in BST using O(1) Extra Space
• Shuffle 2n integers as a1-b1-a2-b2-a3-b3-..bn without using extra space
• Shuffle array {a1, a2, .. an, b1, b2, .. bn} as {a1, b1, a2, b2, a3, b3, ……, an, bn} without using extra space
• Merge two BSTs with limited extra space
• k smallest elements in same order using O(1) extra space
• Merge two sorted arrays with O(1) extra space

Improved By : Sriharsha Sammeta, Sam007, Akanksha_Rai, kenbrooker, Rajput-Ji, more

princiraj1992, 29AjayKumar