这段代码如何从排序数组中删除重复项？

Question

If I pass in a number, an array 2, 3, 3, 3, 1 , for example. It removes the duplicates of 3, but why? and the result is 123 (which it should, because of the sorting method).

Sortering.sorterHeltallstabell(tab) is only sorting my code, while the rest removes the duplicates. It gets sorted before duplicates are removed.

Why does this code remove duplicates of an array when you pass it into the method?

public static int[] utenDubletter(int[] tab){
    Sortering.sorterHeltallstabell(tab);

    if (tab.length < 2)
        return tab;

    //why does this code remove duplicates?
    int j = 0;
    int i = 1;

    while (i < tab.length) {
        if (tab[i] == tab[j]) {
            i++;
        } else {
            j++;
            tab[j] = tab[i];
            i++;
        }           
    }              
    int[] B = Arrays.copyOf(tab, j + 1);
    return B;
}

Answer 1

Dig this simulation:

Start
[1, 1, 1, 2, 2, 2, 3]
 j  i
Duplicate found (tab[i] == tab[j]), move i over 1 (i++)
[1, 1, 1, 2, 2, 2, 3]
 j     i
Duplicate found, move i over 1
[1, 1, 1, 2, 2, 2, 3]
 j        i
Non-duplicate (else); adding 1 to j (j++), 
    copying element i to el j (tab[j] = tab[i]), 
    adding 1 to i (i++)
[1, 2, 1, 2, 2, 2, 3]
    j        i
Duplicate found, move i over 1
[1, 2, 1, 2, 2, 2, 3]
    j           i
Duplicate found, move i over 1
[1, 2, 1, 2, 2, 2, 3]
    j              i
Non-duplicate; adding 1 to j, copying i to j, adding 1 to i
[1, 2, 3, 2, 2, 2, 3]
       j              i
i == tab.length, so stop
Copy first 3 elements of array (up to j) to result 
    (int[] B = Arrays.copyOf(tab, j + 1)) and return it

Answer 2

This works because the code under

if (tab[i] == tab[j])

iterates through the sorted array, skipping duplicated elements and instead copying each unique element forward to the front part of the array, just after the already scanned (and known to be unique elements). It then only keeps that front part of the array.

Stepping through the code:

if (tab.length < 2)
    return tab;

int j = 0;
int i = 1;

Method gets input: [1,1,1,2,2,2,3], is sorted (since the input is already sorted in this example, there is no change), tab is greater than 2, so do not return. j is assigned the value 0 i is assigned the value 1

while (i < tab.length) { ... }

i (which is 1) is less than the tab length (which is 7). While loop is entered:

    if (tab[i] == tab[j]) {
        i++;
    } else {
        j++;
        tab[j] = tab[i];
        i++;
    }       

Iteration 1: tab[i], which is tab[1], which is 1, is compared to tab[j], which is tab[0], which is 1. They are equal, so i is incremented. i is now 2.

Iteration 2: tab[i] (tab[2], or 1) is compared to tab[j] (tab[0] or 1). They are equal, so i is incremented. i is now 3.

Iteration 3: tab[i] (tab[3], or 2) is compared to tab[j] (tab[0] or 1). They are not equal. j is incremented, and is now 1. tab[j] (tab[1]) is assigned the value of tab[i] (tab[3]). tab is now [1,2,1,2,2,2,3]. i is incremented, and is now 4.

Iteration 4: tab[i] (tab[4], or 2) is compared to tab[j] (tab[1] or 2). They are equal, so i is incremented. i is now 5.

Iteration 5: tab[i] (tab[5], or 2) is compared to tab[j] (tab[1] or 2). They are equal, so i is incremented. i is now 6.

Iteration 6: tab[i] (tab[6], or 3) is compared to tab[j] (tab[1] or 2). They are not equal. j is incremented, and is now 2. tab[j] (tab[2]) is assigned the value of tab[i] (tab[6]). tab is now [1,2,3,2,2,2,3]. i is incremented, and is now 7.

I is now no longer less than the length of tab, we exit the while loop.

int[] B = Arrays.copyOf(tab, j + 1);
return B;

B is created by copying tab up to length j + 1, or 3, starting from the first element. B is now [1,2,3].

Method returns [1,2,3], as expected.

Answer 3

It is obvious that with the line

if (tab[i] == tab[j])

you can skip an element of the array if two consecutive elements are the same.

Answer 4

There are a few important considerations for this duplicate removal portion of the code.

• It is actually overwriting the contents of the array in the middle of determining duplicates. It's using the front part of the array (which has already been checked previously) to store the contents of the non-duplicates. Since Java passes objects by value (specifically value of reference), changes to the local copy of the parameter won't be propagated back in the calling method. This is not true for languages that pass objects by reference (like C#), so this algorithm would not work there.

• This algorithm depends on the fact that sorting the array puts all of the same duplicate into a single continuous block of indexes. This guarantees that all future elements will never match something that was previously overwritten many iterations ago (because it is at least the size of the current maximum, else the array wasn't actually sorted properly).

Heavily commented explanation

public static int[] utenDubletter(int[] tab){
    //sort the array
    Sortering.sorterHeltallstabell(tab);

    //There must be at least 2 elements for any duplicate to exist
    if (tab.length < 2)
        return tab;

    int j = 0; //index of the largest element in the new array found so far
    int i = 1; //index of the current index of the array being checked

    while (i < tab.length) {
        //if it's a duplicate 
        if (tab[i] == tab[j]) {
            i++;    //just skip this element and check the next one
        } else {
            j++;    //since this number does not exist in the new array make space for it 
            tab[j] = tab[i];    //record this new element
                                //we have checked this element (with i) before this 
                                //so we don't need to keep it around any longer
            i++;    //move onto the next element 
        }           
    }              
    int[] B = Arrays.copyOf(tab, j + 1);    //copy only the elements that we actually 
                                            //manually overwrote. Since arrays are
                                            //0-indexed, add one to the final index (j)
                                            //for the number of elements in our new array.
    return B;
}