Algoritmo: modo efficiente per rimuovere interi duplicati da un array

Ho avuto questo problema da un'intervista con Microsoft.

Dato un array di numeri interi casuali, scrivi un algoritmo in C che rimuova i numeri duplicati e restituisca i numeri univoci nell'array originale.

Ad esempio Ingresso: {4, 8, 4, 1, 1, 2, 9} Uscita:{4, 8, 1, 2, 9, ?, ?}

Un avvertimento è che l'algoritmo previsto non dovrebbe richiedere prima l'ordinamento dell'array. E quando un elemento è stato rimosso, anche i seguenti elementi devono essere spostati in avanti. Ad ogni modo, il valore degli elementi alla fine della matrice in cui gli elementi sono stati spostati in avanti sono trascurabili.

Aggiornamento: il risultato deve essere restituito nell'array originale e la struttura dei dati di supporto (ad es. Tabella hash) non deve essere utilizzata. Tuttavia, immagino che la conservazione dell'ordine non sia necessaria.

Update2: Per coloro che si chiedono perché questi vincoli poco pratici, questa era una domanda da intervista e tutti questi vincoli vengono discussi durante il processo di pensiero per vedere come posso trovare idee diverse.

Che ne dite di:

void rmdup(int *array, int length)
{
    int *current , *end = array + length - 1;

    for ( current = array + 1; array < end; array++, current = array + 1 )
    {
        while ( current <= end )
        {
            if ( *current == *array )
            {
                *current = *end--;
            }
            else
            {
                current++;
            }
        }
    }
}

Dovrebbe essere O (n ^ 2) o inferiore.

Una soluzione suggerita dalla mia ragazza è una variazione del merge sort. L'unica modifica è che durante la fase di unione, ignorare semplicemente i valori duplicati. Questa soluzione sarebbe anche O (n log n). In questo approccio, l'ordinamento / rimozione della duplicazione vengono combinati insieme. Tuttavia, non sono sicuro che questo faccia la differenza.

L'ho già pubblicato una volta su SO, ma lo riprodurrò qui perché è piuttosto interessante. Usa l'hashing, costruendo qualcosa come un set di hash sul posto. È garantito che sia O (1) nello spazio ascellare (la ricorsione è una chiamata di coda), ed è tipicamente O (N) complessità temporale. L'algoritmo è il seguente:

1. Prendi il primo elemento dell'array, questa sarà la sentinella.
2. Riordina il resto dell'array, per quanto possibile, in modo che ogni elemento si trovi nella posizione corrispondente al suo hash. Al termine di questo passaggio, verranno rilevati i duplicati. Impostali uguali a sentinella.
3. Sposta tutti gli elementi per cui l'indice è uguale all'hash all'inizio della matrice.
4. Sposta tutti gli elementi che sono uguali a sentinel, tranne il primo elemento della matrice, alla fine della matrice.
5. Ciò che rimane tra gli elementi correttamente hash e gli elementi duplicati saranno gli elementi che non è stato possibile posizionare nell'indice corrispondente al loro hash a causa di una collisione. Ricorso per affrontare questi elementi.

Questo può essere dimostrato essere O (N) a condizione che non vi sia alcuno scenario patologico nell'hashing: anche se non ci sono duplicati, circa 2/3 degli elementi verranno eliminati ad ogni ricorsione. Ogni livello di ricorsione è O (n) dove piccolo n è la quantità di elementi rimasti. L'unico problema è che, in pratica, è più lento di un ordinamento rapido quando ci sono pochi duplicati, cioè molte collisioni. Tuttavia, quando ci sono enormi quantità di duplicati, è incredibilmente veloce.

Modifica: nelle attuali implementazioni di D, hash_t è di 32 bit. Tutto ciò che riguarda questo algoritmo presuppone che ci saranno pochissime, se non nessuna, collisioni hash nello spazio completo a 32 bit. Tuttavia, le collisioni possono verificarsi frequentemente nello spazio del modulo. Tuttavia, questa ipotesi sarà con ogni probabilità vera per qualsiasi set di dati di dimensioni ragionevoli. Se la chiave è minore o uguale a 32 bit, può essere il proprio hash, il che significa che una collisione nello spazio completo di 32 bit è impossibile. Se è più grande, semplicemente non ne puoi inserire abbastanza nello spazio degli indirizzi di memoria a 32 bit perché sia ​​un problema. Presumo che hash_t verrà aumentato a 64 bit nelle implementazioni a 64 bit di D, dove i set di dati possono essere più grandi. Inoltre, se questo dovesse mai rivelarsi un problema, si potrebbe cambiare la funzione hash ad ogni livello di ricorsione.

Ecco un'implementazione nel linguaggio di programmazione D:

void uniqueInPlace(T)(ref T[] dataIn) {
    uniqueInPlaceImpl(dataIn, 0);
}

void uniqueInPlaceImpl(T)(ref T[] dataIn, size_t start) {
    if(dataIn.length - start < 2)
        return;

    invariant T sentinel = dataIn[start];
    T[] data = dataIn[start + 1..$];

    static hash_t getHash(T elem) {
        static if(is(T == uint) || is(T == int)) {
            return cast(hash_t) elem;
        } else static if(__traits(compiles, elem.toHash)) {
            return elem.toHash;
        } else {
            static auto ti = typeid(typeof(elem));
            return ti.getHash(&elem);
        }
    }

    for(size_t index = 0; index < data.length;) {
        if(data[index] == sentinel) {
            index++;
            continue;
        }

        auto hash = getHash(data[index]) % data.length;
        if(index == hash) {
            index++;
            continue;
        }

        if(data[index] == data[hash]) {
            data[index] = sentinel;
            index++;
            continue;
        }

        if(data[hash] == sentinel) {
            swap(data[hash], data[index]);
            index++;
            continue;
        }

        auto hashHash = getHash(data[hash]) % data.length;
        if(hashHash != hash) {
            swap(data[index], data[hash]);
            if(hash < index)
                index++;
        } else {
            index++;
        }
    }


    size_t swapPos = 0;
    foreach(i; 0..data.length) {
        if(data[i] != sentinel && i == getHash(data[i]) % data.length) {
            swap(data[i], data[swapPos++]);
        }
    }

    size_t sentinelPos = data.length;
    for(size_t i = swapPos; i < sentinelPos;) {
        if(data[i] == sentinel) {
            swap(data[i], data[--sentinelPos]);
        } else {
            i++;
        }
    }

    dataIn = dataIn[0..sentinelPos + start + 1];
    uniqueInPlaceImpl(dataIn, start + swapPos + 1);
}

Un'implementazione più efficiente

int i, j;

/* new length of modified array */
int NewLength = 1;

for(i=1; i< Length; i++){

   for(j=0; j< NewLength ; j++)
   {

      if(array[i] == array[j])
      break;
   }

   /* if none of the values in index[0..j] of array is not same as array[i],
      then copy the current value to corresponding new position in array */

  if (j==NewLength )
      array[NewLength++] = array[i];
}

In questa implementazione non è necessario ordinare l'array. Inoltre, se viene trovato un elemento duplicato, non è necessario spostare tutti gli elementi successivi di una posizione.

L'output di questo codice è array [] con dimensione NewLength

Qui stiamo iniziando dal 2 ° elemento in array e confrontandolo con tutti gli elementi in array fino a questo array. Stiamo tenendo una variabile di indice extra 'NewLength' per modificare l'array di input. La variabile NewLength è inizializzata a 0.

L'elemento nell'array [1] verrà confrontato con l'array [0]. Se sono diversi, il valore in array [NewLength] verrà modificato con array [1] e incrementerà NewLength. Se sono uguali, NewLength non verrà modificato.

Quindi, se abbiamo un array [1 2 1 3 1], allora

Nel primo passaggio del ciclo 'j', array [1] (2) verrà confrontato con array0, quindi 2 verrà scritto in array [NewLength] = array [1] quindi array sarà [1 2] poiché NewLength = 2

Nel secondo passaggio del ciclo 'j', array [2] (1) verrà confrontato con array0 e array1. In questo caso, poiché array [2] (1) e array0 sono lo stesso ciclo, qui si interromperà. quindi array sarà [1 2] poiché NewLength = 2

e così via

Se stai cercando la notazione O superiore, ordinare l'array con un ordinamento O (n log n) e quindi eseguire un attraversamento O (n) potrebbe essere la strada migliore. Senza l'ordinamento, stai guardando O (n ^ 2).

Modifica: se stai solo facendo numeri interi, puoi anche eseguire l'ordinamento digitale per ottenere O (n).

1. Usando O (1) spazio extra, in tempo O (n log n)

Questo è possibile, ad esempio:

• prima esegui un ordinamento sul posto O (n log n)
• quindi scorrere l'elenco una volta, scrivendo la prima istanza di ogni indietro all'inizio dell'elenco

Credo che il partner di ejel abbia ragione sul fatto che il modo migliore per farlo sarebbe un ordinamento sul posto con un passaggio di unione semplificato, e che questo è probabilmente l'intento della domanda, se tu fossi ad es. scrivere una nuova funzione di libreria per farlo nel modo più efficiente possibile senza alcuna possibilità di migliorare gli input, e in alcuni casi sarebbe utile farlo senza una tabella hash, a seconda del tipo di input. Ma in realtà non l'ho controllato.

2. Utilizzando O (lotti) spazio extra, in O (n) tempo

• dichiarare un array zero abbastanza grande da contenere tutti i numeri interi
• attraversare l'array una volta
• imposta l'elemento della matrice corrispondente su 1 per ogni numero intero.
• Se era già 1, salta il numero intero.

Funziona solo se sussistono diversi presupposti discutibili:

• è possibile azzerare la memoria in modo economico, oppure la dimensione degli int è piccola rispetto al numero di essi
• sei felice di chiedere al tuo sistema operativo 256 ^ sizepof (int) memory
• e lo memorizzerà per te in modo davvero molto efficiente se è gigantesco

È una cattiva risposta, ma se hai MOLTI elementi di input, ma sono tutti interi a 8 bit (o forse anche interi a 16 bit) potrebbe essere il modo migliore.

3. O (poco) -ish spazio extra, O (n) -ish tempo

Come # 2, ma usa una tabella hash.

4. Il modo chiaro

Se il numero di elementi è piccolo, scrivere un algoritmo appropriato non è utile se altro codice è più veloce da scrivere e più veloce da leggere.

Per esempio. Esamina l'array per ogni elemento univoco (cioè il primo elemento, il secondo elemento (i duplicati del primo sono stati rimossi) ecc.) Rimuovendo tutti gli elementi identici. O (1) spazio extra, O (n ^ 2) tempo.

Per esempio. Usa le funzioni di libreria che lo fanno. l'efficienza dipende da quello che hai facilmente a disposizione.

Bene, l'implementazione di base è abbastanza semplice. Passa attraverso tutti gli elementi, controlla se ci sono duplicati in quelli rimanenti e sposta il resto su di essi.

È terribilmente inefficiente e potresti accelerarlo con un array di supporto per l'output o gli alberi di ordinamento / binari, ma questo non sembra essere consentito.

Se puoi usare C ++, una chiamata a std::sortseguita da una chiamata a std::uniqueti darà la risposta. La complessità temporale è O (N log N) per l'ordinamento e O (N) per l'attraversamento unico.

E se C ++ è fuori dal tavolo non c'è niente che impedisce che questi stessi algoritmi vengano scritti in C.

Potresti farlo in una singola traversata, se sei disposto a sacrificare la memoria. Puoi semplicemente calcolare se hai visto o meno un numero intero in un array hash / associativo. Se hai già visto un numero, rimuovilo mentre procedi, o meglio ancora, sposta i numeri che non hai visto in un nuovo array, evitando qualsiasi spostamento nell'array originale.

In Perl:

foreach $i (@myary) {
    if(!defined $seen{$i}) {
        $seen{$i} = 1;
        push @newary, $i;
    }
}

Il valore di ritorno della funzione dovrebbe essere il numero di elementi univoci e sono tutti memorizzati nella parte anteriore della matrice. Senza queste informazioni aggiuntive, non saprai nemmeno se ci sono stati duplicati.

Ogni iterazione del ciclo esterno elabora un elemento dell'array. Se è univoco, resta in primo piano nell'array e se è un duplicato viene sovrascritto dall'ultimo elemento non elaborato dell'array. Questa soluzione viene eseguita in tempo O (n ^ 2).

#include <stdio.h>
#include <stdlib.h>

size_t rmdup(int *arr, size_t len)
{
  size_t prev = 0;
  size_t curr = 1;
  size_t last = len - 1;
  while (curr <= last) {
    for (prev = 0; prev < curr && arr[curr] != arr[prev]; ++prev);
    if (prev == curr) {
      ++curr;
    } else {
      arr[curr] = arr[last];
      --last;
    }
  }
  return curr;
}

void print_array(int *arr, size_t len)
{
  printf("{");
  size_t curr = 0;
  for (curr = 0; curr < len; ++curr) {
    if (curr > 0) printf(", ");
    printf("%d", arr[curr]);
  }
  printf("}");
}

int main()
{
  int arr[] = {4, 8, 4, 1, 1, 2, 9};
  printf("Before: ");
  size_t len = sizeof (arr) / sizeof (arr[0]);
  print_array(arr, len);
  len = rmdup(arr, len);
  printf("\nAfter: ");
  print_array(arr, len);
  printf("\n");
  return 0;
}

Ecco una versione Java.

int[] removeDuplicate(int[] input){

        int arrayLen = input.length;
        for(int i=0;i<arrayLen;i++){
            for(int j = i+1; j< arrayLen ; j++){
                if(((input[i]^input[j]) == 0)){
                    input[j] = 0;
                }
                if((input[j]==0) && j<arrayLen-1){
                        input[j] = input[j+1];
                        input[j+1] = 0;
                    }               
            }
        }       
        return input;       
    }

Ecco la mia soluzione.

///// find duplicates in an array and remove them

void unique(int* input, int n)
{
     merge_sort(input, 0, n) ;

     int prev = 0  ;

     for(int i = 1 ; i < n ; i++)
     {
          if(input[i] != input[prev])
               if(prev < i-1)
                   input[prev++] = input[i] ;                         
     }
}

Un array dovrebbe ovviamente essere "attraversato" da destra a sinistra per evitare la copia inutile dei valori avanti e indietro.

Se disponi di memoria illimitata, puoi allocare un array di bit per sizeof(type-of-element-in-array) / 8byte in modo che ogni bit indichi se hai già incontrato il valore corrispondente o meno.

Se non lo fai, non riesco a pensare a niente di meglio che attraversare un array e confrontare ogni valore con i valori che lo seguono e quindi se viene trovato un duplicato, rimuovi del tutto questi valori. Questo è da qualche parte vicino a O (n ^ 2) (o O ((n ^ 2-n) / 2) ).

IBM ha un articolo su un argomento piuttosto vicino.

Vediamo:

• O (N) passare per trovare allocazione min / max
• matrice di bit per trovato
• O (N) passa lo scambio di duplicati alla fine.

Questo può essere fatto in un solo passaggio con un algoritmo O (N log N) e senza spazio di archiviazione aggiuntivo.

Procedi dall'elemento a[1]a a[N]. In ogni fase i, tutti gli elementi a sinistra di a[i]comprendono un mucchio ordinato di elementi a[0]attraverso a[j]. Nel frattempo, un secondo indice j, inizialmente 0, tiene traccia della dimensione dell'heap.

Esaminalo a[i]e inseriscilo nell'heap, che ora occupa gli elementi a[0]per a[j+1]. Quando l'elemento viene inserito, se a[k]si incontra un elemento duplicato con lo stesso valore, non inserirlo a[i]nell'heap (ovvero scartarlo); altrimenti inserirla nel cumulo, che ora cresce da un elemento e comprende ora a[0]a a[j+1], e l'incremento j.

Continua in questo modo, incrementando ifino a quando tutti gli elementi dell'array non sono stati esaminati e inseriti nell'heap, che finisce per occupare a[0]a a[j]. jè l'indice dell'ultimo elemento dell'heap e l'heap contiene solo valori di elemento univoci.

int algorithm(int[] a, int n)
{
    int   i, j;  

    for (j = 0, i = 1;  i < n;  i++)
    {
        // Insert a[i] into the heap a[0...j]
        if (heapInsert(a, j, a[i]))
            j++;
    }
    return j;
}  

bool heapInsert(a[], int n, int val)
{
    // Insert val into heap a[0...n]
    ...code omitted for brevity...
    if (duplicate element a[k] == val)
        return false;
    a[k] = val;
    return true;
}

Guardando l'esempio, questo non è esattamente ciò che è stato richiesto poiché l'array risultante conserva l'ordine originale degli elementi. Ma se questo requisito è rilassato, l'algoritmo sopra dovrebbe fare il trucco.

In Java lo risolverei in questo modo. Non so come scrivere questo in C.

   int length = array.length;
   for (int i = 0; i < length; i++) 
   {
      for (int j = i + 1; j < length; j++) 
      {
         if (array[i] == array[j]) 
         {
            int k, j;
            for (k = j + 1, l = j; k < length; k++, l++) 
            {
               if (array[k] != array[i]) 
               {
                  array[l] = array[k];
               }
               else
               {
                  l--;
               }
            }
            length = l;
         }
      }
   }

Che ne dici di quanto segue?

int* temp = malloc(sizeof(int)*len);
int count = 0;
int x =0;
int y =0;
for(x=0;x<len;x++)
{
    for(y=0;y<count;y++)
    {
        if(*(temp+y)==*(array+x))
        {
            break;
        }
    }
    if(y==count)
    {
        *(temp+count) = *(array+x);
        count++;
    }
}
memcpy(array, temp, sizeof(int)*len);

Provo a dichiarare un array temporaneo e inserire gli elementi in quello prima di copiare tutto nell'array originale.

Dopo aver esaminato il problema, ecco il mio metodo delphi, che potrebbe aiutare

var
A: Array of Integer;
I,J,C,K, P: Integer;
begin
C:=10;
SetLength(A,10);
A[0]:=1; A[1]:=4; A[2]:=2; A[3]:=6; A[4]:=3; A[5]:=4;
A[6]:=3; A[7]:=4; A[8]:=2; A[9]:=5;

for I := 0 to C-1 do
begin
  for J := I+1 to C-1 do
    if A[I]=A[J] then
    begin
      for K := C-1 Downto J do
        if A[J]<>A[k] then
        begin
          P:=A[K];
          A[K]:=0;
          A[J]:=P;
          C:=K;
          break;
        end
        else
        begin
          A[K]:=0;
          C:=K;
        end;
    end;
end;

//tructate array
setlength(A,C);
end;

Il seguente esempio dovrebbe risolvere il tuo problema:

def check_dump(x):
   if not x in t:
      t.append(x)
      return True

t=[]

output = filter(check_dump, input)

print(output)
True

import java.util.ArrayList;


public class C {

    public static void main(String[] args) {

        int arr[] = {2,5,5,5,9,11,11,23,34,34,34,45,45};

        ArrayList<Integer> arr1 = new ArrayList<Integer>();

        for(int i=0;i<arr.length-1;i++){

            if(arr[i] == arr[i+1]){
                arr[i] = 99999;
            }
        }

        for(int i=0;i<arr.length;i++){
            if(arr[i] != 99999){

                arr1.add(arr[i]);
            }
        }

        System.out.println(arr1);
}
    }

Questa è la soluzione ingenua (N * (N-1) / 2). Utilizza uno spazio aggiuntivo costante e mantiene l'ordine originale. È simile alla soluzione di @Byju, ma non utilizza if(){}blocchi. Inoltre evita di copiare un elemento su se stesso.

#include <stdio.h>
#include <stdlib.h>

int numbers[] = {4, 8, 4, 1, 1, 2, 9};
#define COUNT (sizeof numbers / sizeof numbers[0])

size_t undup_it(int array[], size_t len)
{
size_t src,dst;

  /* an array of size=1 cannot contain duplicate values */
if (len <2) return len; 
  /* an array of size>1 will cannot at least one unique value */
for (src=dst=1; src < len; src++) {
        size_t cur;
        for (cur=0; cur < dst; cur++ ) {
                if (array[cur] == array[src]) break;
                }
        if (cur != dst) continue; /* found a duplicate */

                /* array[src] must be new: add it to the list of non-duplicates */
        if (dst < src) array[dst] = array[src]; /* avoid copy-to-self */
        dst++;
        }
return dst; /* number of valid alements in new array */
}

void print_it(int array[], size_t len)
{
size_t idx;

for (idx=0; idx < len; idx++)  {
        printf("%c %d", (idx) ? ',' :'{' , array[idx] );
        }
printf("}\n" );
}

int main(void) {    
    size_t cnt = COUNT;

    printf("Before undup:" );    
    print_it(numbers, cnt);    

    cnt = undup_it(numbers,cnt);

    printf("After undup:" );    
    print_it(numbers, cnt);

    return 0;
}

Questa operazione può essere eseguita in un unico passaggio, nel tempo O (N) nel numero di numeri interi nell'elenco di input e nell'archiviazione O (N) nel numero di interi univoci.

Scorri l'elenco da davanti a dietro, con due puntatori "dst" e "src" inizializzati sul primo elemento. Inizia con una tabella hash vuota di "numeri interi visti". Se il numero intero in src non è presente nell'hash, scriverlo nello slot in dst e incrementare dst. Aggiungi il numero intero in src all'hash, quindi incrementa src. Ripeti finché src non supera la fine dell'elenco di input.

Inserisci tutti gli elementi in a binary tree the disregards duplicates- O(nlog(n)). Quindi estrarli tutti di nuovo nell'array eseguendo un attraversamento - O(n). Presumo che tu non abbia bisogno della conservazione dell'ordine.

Usa il filtro bloom per l'hashing. Ciò ridurrà notevolmente il sovraccarico della memoria.

In JAVA,

    Integer[] arrayInteger = {1,2,3,4,3,2,4,6,7,8,9,9,10};

    String value ="";

    for(Integer i:arrayInteger)
    {
        if(!value.contains(Integer.toString(i))){
            value +=Integer.toString(i)+",";
        }

    }

    String[] arraySplitToString = value.split(",");
    Integer[] arrayIntResult = new Integer[arraySplitToString.length];
    for(int i = 0 ; i < arraySplitToString.length ; i++){
        arrayIntResult[i] = Integer.parseInt(arraySplitToString[i]);
    }

output: {1, 2, 3, 4, 6, 7, 8, 9, 10}

spero che questo possa aiutare

Crea un BinarySearchTreecon complessità O (n).

Per prima cosa, dovresti creare un array check[n]dove n è il numero di elementi dell'array che vuoi rendere privi di duplicati e impostare il valore di ogni elemento (dell'array di controllo) uguale a 1. Usando un ciclo for attraversare l'array con il duplicati, diciamo che il suo nome è arr, e nel ciclo for scrivi questo:

{
    if (check[arr[i]] != 1) {
        arr[i] = 0;
    }
    else {
        check[arr[i]] = 0;
    }
}

Con ciò, imposti ogni duplicato uguale a zero. Quindi l'unica cosa che resta da fare è attraversare l' arrarray e stampare tutto ciò che non è uguale a zero. L'ordine rimane e richiede tempo lineare (3 * n).

Dato un array di n elementi, scrivi un algoritmo per rimuovere tutti i duplicati dall'array nel tempo O (nlogn)

Algorithm delete_duplicates (a[1....n])
//Remove duplicates from the given array 
//input parameters :a[1:n], an array of n elements.

{

temp[1:n]; //an array of n elements. 

temp[i]=a[i];for i=1 to n

 temp[i].value=a[i]

temp[i].key=i

 //based on 'value' sort the array temp.

//based on 'value' delete duplicate elements from temp.

//based on 'key' sort the array temp.//construct an array p using temp.

 p[i]=temp[i]value

  return p.

In altri elementi viene mantenuto nell'array di output utilizzando la 'chiave'. Considera che la chiave è di lunghezza O (n), il tempo impiegato per eseguire l'ordinamento sulla chiave e il valore è O (nlogn). Quindi il tempo impiegato per eliminare tutti i duplicati dall'array è O (nlogn).

questo è quello che ho, anche se sbaglia l'ordine che possiamo ordinare in ordine crescente o decrescente per risolverlo.

#include <stdio.h>
int main(void){
int x,n,myvar=0;
printf("Enter a number: \t");
scanf("%d",&n);
int arr[n],changedarr[n];

for(x=0;x<n;x++){
    printf("Enter a number for array[%d]: ",x);
    scanf("%d",&arr[x]);
}
printf("\nOriginal Number in an array\n");
for(x=0;x<n;x++){
    printf("%d\t",arr[x]);
}

int i=0,j=0;
// printf("i\tj\tarr\tchanged\n");

for (int i = 0; i < n; i++)
{
    // printf("%d\t%d\t%d\t%d\n",i,j,arr[i],changedarr[i] );
    for (int j = 0; j <n; j++)
    {   
        if (i==j)
        {
            continue;

        }
        else if(arr[i]==arr[j]){
            changedarr[j]=0;

        }
        else{
            changedarr[i]=arr[i];

        }
    // printf("%d\t%d\t%d\t%d\n",i,j,arr[i],changedarr[i] );
    }
    myvar+=1;
}
// printf("\n\nmyvar=%d\n",myvar);
int count=0;
printf("\nThe unique items:\n");
for (int i = 0; i < myvar; i++)
{
        if(changedarr[i]!=0){
            count+=1;
            printf("%d\t",changedarr[i]);   
        }
}
    printf("\n");
}

Sarebbe bello se tu avessi una buona DataStructure che potrebbe dire rapidamente se contiene un numero intero. Forse un albero di qualche tipo.

DataStructure elementsSeen = new DataStructure();
int elementsRemoved = 0;
for(int i=0;i<array.Length;i++){
  if(elementsSeen.Contains(array[i])
    elementsRemoved++;
  else
    array[i-elementsRemoved] = array[i];
}
array.Length = array.Length - elementsRemoved;