在时间复杂度 O(n) 和空间复杂度 O(1) 中查找数组中重复元素的最有效算法是什么？

Question

Note- You can not use Collection or Map

I have tried this but this is not having complexity O(n)

class RepeatElement  
{ 
    void printRepeating(int arr[], int size)  
    { 
        int i, j; 
        System.out.println("Repeated Elements are :"); 
        for (i = 0; i < size; i++)  
        { 
            for (j = i + 1; j < size; j++)  
            { 
                if (arr[i] == arr[j])  
                    System.out.print(arr[i] + " "); 
            } 
        } 
    } 

    public static void main(String[] args)  
    { 
        RepeatElement repeat = new RepeatElement(); 
        int arr[] = {4, 2, 4, 5, 2, 3, 1}; 
        int arr_size = arr.length; 
        repeat.printRepeating(arr, arr_size); 
    } 
} 

Is any one having solution for solving,to find a duplicate array without using Collection or Map and using only single for loop

Answer 1

If the elements in an array with size n are in a range of 0 ~ n-1 ( or 1 ~ n ).

We can try to sort the array by putting a[i] to index i for every a[i] != i , and if we find that there is already an a[i] at index i , it means that there is another element with value a[i] .

for (int i = 0; i < a.length; i++){
  while (a[i] != i) {
    if (a[i] == a[a[i]]) {
      System.out.print(a[i]);
      break;
    } else {
      int temp = a[i];  // Putting a[i] to index i by swapping them
      a[i] = a[a[i]];
      a[temp] = temp;
    }
  }
}

Since after every swap, one of the elements will be in the right position, so there will be at most n swap operations.

Time complexity O(n)

Space complexity O(1)

Answer 2

Ok, so you have a constant memory requirement for an array of type int ?
No problem, just let's use a large (but constant) byte array:

byte[] seen = new byte[536870912];
byte[] dups = new byte[536870912];
for (int i : arr) {
    int idx = i / 8 + 268435456;
    int mask = 1 << (i % 8);
    if ((seen[idx] & mask) != 0) {
        if ((dups[idx] & mask) == 0) {
            System.out.print(i + " ");
            dups[idx] |= mask;
        }
    } else {
        seen[idx] |= mask;
    }    
}

As we only iterate once over the array, we have a time complexity of O(n) (where n is the number of elements in the array).
And because we always use the same amount of space we have a memory complexity of O(1), that is independent of anything.

Answer 3

As these are int s, you could use a BitSet :

void printRepeating(int arr[], int size) {
    BitSet bits = new BitSet();
    BitSet repeated = new BitSet();

    //to deal with negative ints:
    BitSet negativeBits = new BitSet();
    BitSet negativeRepeatedBits = new BitSet();

    for(int i : arr) {
        if(i<0) {
            i = -i; //use the absolute value
            if(negativeBits.get(i)) {
                //this is a repeat
                negativeRepeatedBits.set(i);
            }
            negativeBits.set(i);
        } else {
            if(bits.get(i)) {
                //this is a repeat
                repeated.set(i);
            }
            bits.set(i);
        }
    }
    System.out.println(
            IntStream.concat(negativeRepeatedBits.stream().map(i -> -i), repeated.stream())
                .mapToObj(String::valueOf)
                .collect(Collectors.joining(", ", "Repated Elements are : ", ""))
        );
}

Note that (as per comment) negative values need to be treated separately, as otherwise you could be faced with IndexOutOfBoundsException .

Answer 4

Just one for loop, i will increment when j is at the end of the array, the current arr[i] is found earlier of a new duplicate element is found

    void printRepeatingSingleLoop(int arr[], int size)
    {
        int i, j, k;
        System.out.println("Repeated Elements are :");
        for (i = 0, j = 1, k = 0; i < size; )
        {
            if (k < i ) {
                if (arr[i] == arr[k]) {
                    i++;
                    j = i+1;
                    k = 0;
                } else {
                    k++;
                }
            } else {
                if (j == size) {
                    i++;
                    j = i + 1;
                    k = 0;
                } else {
                    if (arr[i] == arr[j]) {
                        System.out.print(arr[i] + " ");
                        i++;
                        j = i + 1;
                        k = 0;
                    } else {
                        j++;
                    }
                }
            }
        }
        System.out.println();
    }