Cómo eliminar eficientemente los duplicados de una matriz sin usar Set

Me pidieron que escribiera mi propia implementación para eliminar los valores duplicados en una matriz. Esto es lo que he creado. Pero después de las pruebas con 1,000,000 de elementos, tomó mucho tiempo terminar. ¿Hay algo que pueda hacer para mejorar mi algoritmo o cualquier error que eliminar?

Necesito escribir mi propia implementación, no usar Set , HashSet , etc. O cualquier otra herramienta como iteradores. Simplemente una matriz para eliminar duplicados.

 public static int[] removeDuplicates(int[] arr) { int end = arr.length; for (int i = 0; i < end; i++) { for (int j = i + 1; j < end; j++) { if (arr[i] == arr[j]) { int shiftLeft = j; for (int k = j+1; k < end; k++, shiftLeft++) { arr[shiftLeft] = arr[k]; } end--; j--; } } } int[] whitelist = new int[end]; for(int i = 0; i < end; i++){ whitelist[i] = arr[i]; } return whitelist; } 

puedes tomar la ayuda de la colección Set

 int end = arr.length; Set set = new HashSet(); for(int i = 0; i < end; i++){ set.add(arr[i]); } 

ahora si itera a través de este conjunto , contendrá solo valores únicos. El código de iteración es así:

 Iterator it = set.iterator(); while(it.hasNext()) { System.out.println(it.next()); } 

Nota: Supongo que la matriz está ordenada.

Código:

 int[] input = new int[]{1, 1, 3, 7, 7, 8, 9, 9, 9, 10}; int current = input[0]; boolean found = false; for (int i = 0; i < input.length; i++) { if (current == input[i] && !found) { found = true; } else if (current != input[i]) { System.out.print(" " + current); current = input[i]; found = false; } } System.out.print(" " + current); 

salida:

  1 3 7 8 9 10 

Como puede suponer que el rango está entre 0-1000, hay una solución muy simple y eficiente

 //Throws an exception if values are not in the range of 0-1000 public static int[] removeDuplicates(int[] arr) { boolean[] set = new boolean[1001]; //values must default to false int totalItems = 0; for (int i = 0; i < arr.length; ++i) { if (!set[arr[i]]) { set[arr[i]] = true; totalItems++; } } int[] ret = new int[totalItems]; int c = 0; for (int i = 0; i < set.length; ++i) { if (set[i]) { ret[c++] = i; } } return ret; } 

Esto se ejecuta en tiempo lineal O (n). Advertencia: la matriz devuelta está ordenada de modo que si eso es ilegal, esta respuesta no es válida.

Leve modificación del código original en sí, eliminando el más interno para el bucle.

 public static int[] removeDuplicates(int[] arr){ int end = arr.length; for (int i = 0; i < end; i++) { for (int j = i + 1; j < end; j++) { if (arr[i] == arr[j]) { /*int shiftLeft = j; for (int k = j+1; k < end; k++, shiftLeft++) { arr[shiftLeft] = arr[k]; }*/ arr[j] = arr[end-1]; end--; j--; } } } int[] whitelist = new int[end]; /*for(int i = 0; i < end; i++){ whitelist[i] = arr[i]; }*/ System.arraycopy(arr, 0, whitelist, 0, end); return whitelist; } 
 class Demo { public static void main(String[] args) { int a[]={3,2,1,4,2,1}; System.out.print("Before Sorting:"); for (int i=0;ia[j]) { int temp=a[i]; a[i]=a[j]; a[j]=temp; } } } //After sorting for(int i=0;i 

Existe una gran cantidad de soluciones para este problema.

  1. El enfoque de clasificación

    • Ordena su matriz y solo resuelve elementos únicos
  2. El enfoque establecido

    • Usted declara un HashSet donde coloca todos los artículos, entonces solo tiene únicos.
  3. Usted crea una matriz booleana que representa los elementos que están listos para su devolución, (esto depende de sus datos en la matriz).

Si manejas una gran cantidad de datos elegiría la 1. solución. Como no asigna memoria adicional y la clasificación es bastante rápida. Para pequeños conjuntos de datos, la complejidad sería n ^ 2, pero para grandes i será n log n.

¿Qué sucede si crea dos matrices booleanas: 1 para valores negativos y 1 para valores positivos e inicie todo en falso.

Luego, realiza un ciclo por la matriz de entrada y busca en las matrices si ya has encontrado el valor. De lo contrario, lo agrega a la matriz de salida y lo marca como ya usado.

Esta es una forma simple de ordenar los elementos en la matriz

 public class DublicatesRemove { public static void main(String args[]) throws Exception { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); System.out.println("enter size of the array"); int l = Integer.parseInt(br.readLine()); int[] a = new int[l]; // insert elements in the array logic for (int i = 0; i < l; i++) { System.out.println("enter a element"); int el = Integer.parseInt(br.readLine()); a[i] = el; } // sorting elements in the array logic for (int i = 0; i < l; i++) { for (int j = 0; j < l - 1; j++) { if (a[j] > a[j + 1]) { int temp = a[j]; a[j] = a[j + 1]; a[j + 1] = temp; } } } // remove duplicate elements logic int b = 0; a[b] = a[0]; for (int i = 1; i < l; i++) { if (a[b] != a[i]) { b++; a[b]=a[i]; } } for(int i=0;i<=b;i++) { System.out.println(a[i]); } } } 
 package com.pari.practice; import java.util.HashSet; import java.util.Iterator; import com.pari.sort.Sort; public class RemoveDuplicates { /** * brute force- o(N square) * * @param input * @return */ public static int[] removeDups(int[] input){ boolean[] isSame = new boolean[input.length]; int sameNums = 0; for( int i = 0; i < input.length; i++ ){ for( int j = i+1; j < input.length; j++){ if( input[j] == input[i] ){ //compare same isSame[j] = true; sameNums++; } } } //compact the array into the result. int[] result = new int[input.length-sameNums]; int count = 0; for( int i = 0; i < input.length; i++ ){ if( isSame[i] == true) { continue; } else{ result[count] = input[i]; count++; } } return result; } /** * set - o(N) * does not guarantee order of elements returned - set property * * @param input * @return */ public static int[] removeDups1(int[] input){ HashSet myset = new HashSet(); for( int i = 0; i < input.length; i++ ){ myset.add(input[i]); } //compact the array into the result. int[] result = new int[myset.size()]; Iterator setitr = myset.iterator(); int count = 0; while( setitr.hasNext() ){ result[count] = (int) setitr.next(); count++; } return result; } /** * quicksort - o(Nlogn) * * @param input * @return */ public static int[] removeDups2(int[] input){ Sort st = new Sort(); st.quickSort(input, 0, input.length-1); //input is sorted //compact the array into the result. int[] intermediateResult = new int[input.length]; int count = 0; int prev = Integer.MIN_VALUE; for( int i = 0; i < input.length; i++ ){ if( input[i] != prev ){ intermediateResult[count] = input[i]; count++; } prev = input[i]; } int[] result = new int[count]; System.arraycopy(intermediateResult, 0, result, 0, count); return result; } public static void printArray(int[] input){ for( int i = 0; i < input.length; i++ ){ System.out.print(input[i] + " "); } } public static void main(String[] args){ int[] input = {5,6,8,0,1,2,5,9,11,0}; RemoveDuplicates.printArray(RemoveDuplicates.removeDups(input)); System.out.println(); RemoveDuplicates.printArray(RemoveDuplicates.removeDups1(input)); System.out.println(); RemoveDuplicates.printArray(RemoveDuplicates.removeDups2(input)); } } 

Salida: 5 6 8 0 1 2 9 11

0 1 2 5 6 8 9 11

0 1 2 5 6 8 9 11

Acabo de escribir el código anterior para probarlo. Gracias.

Debe ordenar su matriz y luego repetir y eliminar duplicados. Como no puede usar otras herramientas, debe escribir el código usted mismo.

Puede encontrar fácilmente ejemplos de quicksort en Java en Internet (en el que se basa este ejemplo).

 public static void main(String[] args) throws Exception { final int[] original = new int[]{1, 1, 2, 8, 9, 8, 4, 7, 4, 9, 1}; System.out.println(Arrays.toString(original)); quicksort(original); System.out.println(Arrays.toString(original)); final int[] unqiue = new int[original.length]; int prev = original[0]; unqiue[0] = prev; int count = 1; for (int i = 1; i < original.length; ++i) { if (original[i] != prev) { unqiue[count++] = original[i]; } prev = original[i]; } System.out.println(Arrays.toString(unqiue)); final int[] compressed = new int[count]; System.arraycopy(unqiue, 0, compressed, 0, count); System.out.println(Arrays.toString(compressed)); } private static void quicksort(final int[] values) { if (values.length == 0) { return; } quicksort(values, 0, values.length - 1); } private static void quicksort(final int[] values, final int low, final int high) { int i = low, j = high; int pivot = values[low + (high - low) / 2]; while (i <= j) { while (values[i] < pivot) { i++; } while (values[j] > pivot) { j--; } if (i <= j) { swap(values, i, j); i++; j--; } } if (low < j) { quicksort(values, low, j); } if (i < high) { quicksort(values, i, high); } } private static void swap(final int[] values, final int i, final int j) { final int temp = values[i]; values[i] = values[j]; values[j] = temp; } 

Entonces el proceso se ejecuta en 3 pasos.

  1. Ordenar la matriz - O(nlgn)
  2. Eliminar duplicados - O(n)
  3. Compacte la matriz - O(n)

Por lo tanto, esto mejora significativamente en su enfoque O(n^3) .

Salida:

 [1, 1, 2, 8, 9, 8, 4, 7, 4, 9, 1] [1, 1, 1, 2, 4, 4, 7, 8, 8, 9, 9] [1, 2, 4, 7, 8, 9, 0, 0, 0, 0, 0] [1, 2, 4, 7, 8, 9] 

EDITAR

OP declara que los valores dentro de la matriz realmente no importan. Pero puedo suponer que el rango está entre 0-1000 . Este es un caso clásico en el que se puede usar un tipo O (n).

Creamos una matriz de range +1 de tamaño range +1 , en este caso 1001 . Luego recorremos los datos e incrementamos los valores en cada índice correspondiente al punto de datos.

Entonces podemos compactar la matriz resultante, dejando caer los valores que no se han incrementado. Esto hace que los valores sean únicos ya que ignoramos el recuento.

 public static void main(String[] args) throws Exception { final int[] original = new int[]{1, 1, 2, 8, 9, 8, 4, 7, 4, 9, 1, 1000, 1000}; System.out.println(Arrays.toString(original)); final int[] buckets = new int[1001]; for (final int i : original) { buckets[i]++; } final int[] unique = new int[original.length]; int count = 0; for (int i = 0; i < buckets.length; ++i) { if (buckets[i] > 0) { unique[count++] = i; } } final int[] compressed = new int[count]; System.arraycopy(unique, 0, compressed, 0, count); System.out.println(Arrays.toString(compressed)); } 

Salida:

 [1, 1, 2, 8, 9, 8, 4, 7, 4, 9, 1, 1000, 1000] [1, 2, 4, 7, 8, 9, 1000] 

editar: para una matriz ordenada, solo revisa el siguiente índice

 //sorted data! public static int[] distinct(int[] arr) { int[] temp = new int[arr.lenght]; int count = 0; for (int i = 0; i < arr.length; i++) { int current = arr[i]; if(count > 0 ) if(temp[count - 1] == current) continue; temp[count] = current; count++; } int[] whitelist = new int[count]; System.arraycopy(temp, 0, whitelist, 0, count); return whitelist; } 
 public static void main(String args[]) { int[] intarray = {1,2,3,4,5,1,2,3,4,5,1,2,3,4,5}; Set set = new HashSet(); for(int i : intarray) { set.add(i); } Iterator setitr = set.iterator(); for(int pos=0; pos < intarray.length; pos ++) { if(pos < set.size()) { intarray[pos] =setitr.next(); } else { intarray[pos]= 0; } } for(int i: intarray) System.out.println(i); } 

Sé que esto está un poco muerto, pero acabo de escribir esto para mi propio uso. Es más o menos lo mismo que agregar a un hashset y luego sacar todos los elementos del mismo. Debería ejecutarse en O (nlogn) el peor caso.

  public static int[] removeDuplicates(int[] numbers) { Entry[] entries = new Entry[numbers.length]; int size = 0; for (int i = 0 ; i < numbers.length ; i++) { int nextVal = numbers[i]; int index = nextVal % entries.length; Entry e = entries[index]; if (e == null) { entries[index] = new Entry(nextVal); size++; } else { if(e.insert(nextVal)) { size++; } } } int[] result = new int[size]; int index = 0; for (int i = 0 ; i < entries.length ; i++) { Entry current = entries[i]; while (current != null) { result[i++] = current.value; current = current.next; } } return result; } public static class Entry { int value; Entry next; Entry(int value) { this.value = value; } public boolean insert(int newVal) { Entry current = this; Entry prev = null; while (current != null) { if (current.value == newVal) { return false; } else if(current.next != null) { prev = current; current = next; } } prev.next = new Entry(value); return true; } } 
 int tempvar=0; //Variable for the final array without any duplicates int whilecount=0; //variable for while loop while(whilecount<(nsprtable*2)-1) //nsprtable can be any number { //to check whether the next value is idential in case of sorted array if(temparray[whilecount]!=temparray[whilecount+1]) { finalarray[tempvar]=temparray[whilecount]; tempvar++; whilecount=whilecount+1; } else if (temparray[whilecount]==temparray[whilecount+1]) { finalarray[tempvar]=temparray[whilecount]; tempvar++; whilecount=whilecount+2; } } 

Espero que esto ayude o resuelva el propósito.

Dado que esta pregunta todavía está recibiendo mucha atención, decidí responderla copiando esta respuesta de Code Review.SE :

Estás siguiendo la misma filosofía que el tipo de burbuja, que es muy, muy, muy lento. ¿Has probado esto ?:

  • Clasifica tu matriz desordenada con quicksort . Quicksort es mucho más rápido que sort de burbuja (lo sé, no está ordenando, pero el algoritmo que sigue es casi el mismo que sortear con burbuja para atravesar la matriz).

  • Luego comience a eliminar duplicados (los valores repetidos estarán uno al lado del otro). En un bucle for , puede tener dos índices: source y destination . (En cada ciclo, copie la source a destination menos que sean iguales e incremente ambos en 1). Cada vez que encuentre un duplicado, boostá la fuente (y no realizará la copia). @morgano

 public static int[] removeDuplicates(int[] arr){ HashSet set = new HashSet<>(); final int len = arr.length; //changed end to len for(int i = 0; i < len; i++){ set.add(arr[i]); } int[] whitelist = new int[set.size()]; int i = 0; for (Iterator it = set.iterator(); it.hasNext();) { whitelist[i++] = it.next(); } return whitelist; } 

Se ejecuta en el tiempo O (N) en lugar de su hora O (N ^ 3)

 public static void main(String[] args) { Integer[] intArray = { 1, 1, 1, 2, 4, 2, 3, 5, 3, 6, 7, 3, 4, 5 }; Integer[] finalArray = removeDuplicates(intArray); System.err.println(Arrays.asList(finalArray)); } private static Integer[] removeDuplicates(Integer[] intArray) { int count = 0; Integer[] interimArray = new Integer[intArray.length]; for (int i = 0; i < intArray.length; i++) { boolean exists = false; for (int j = 0; j < interimArray.length; j++) { if (interimArray[j]!=null && interimArray[j] == intArray[i]) { exists = true; } } if (!exists) { interimArray[count] = intArray[i]; count++; } } final Integer[] finalArray = new Integer[count]; System.arraycopy(interimArray, 0, finalArray, 0, count); return finalArray; } 

Siento que la idea de Android Killer es genial, pero me preguntaba si podemos aprovechar HashMap. Así que hice un pequeño experimento. Y descubrí que HashMap parece más rápido que HashSet.

Aquí está el código:

  int[] input = new int[1000000]; for (int i = 0; i < input.length; i++) { Random random = new Random(); input[i] = random.nextInt(200000); } long startTime1 = new Date().getTime(); System.out.println("Set start time:" + startTime1); Set resultSet = new HashSet(); for (int i = 0; i < input.length; i++) { resultSet.add(input[i]); } long endTime1 = new Date().getTime(); System.out.println("Set end time:"+ endTime1); System.out.println("result of set:" + (endTime1 - startTime1)); System.out.println("number of Set:" + resultSet.size() + "\n"); long startTime2 = new Date().getTime(); System.out.println("Map start time:" + startTime1); Map resultMap = new HashMap(); for (int i = 0; i < input.length; i++) { if (!resultMap.containsKey(input[i])) resultMap.put(input[i], input[i]); } long endTime2 = new Date().getTime(); System.out.println("Map end Time:" + endTime2); System.out.println("result of Map:" + (endTime2 - startTime2)); System.out.println("number of Map:" + resultMap.size()); 

Aquí está el resultado:

 Set start time:1441960583837 Set end time:1441960583917 result of set:80 number of Set:198652 Map start time:1441960583837 Map end Time:1441960583983 result of Map:66 number of Map:198652 

Esto no usa Set, Map, List ni ninguna colección adicional, solo dos arrays:

 package arrays.duplicates; import java.lang.reflect.Array; import java.util.Arrays; public class ArrayDuplicatesRemover { public static  T[] removeDuplicates(T[] input, Class clazz) { T[] output = (T[]) Array.newInstance(clazz, 0); for (T t : input) { if (!inArray(t, output)) { output = Arrays.copyOf(output, output.length + 1); output[output.length - 1] = t; } } return output; } private static  boolean inArray(T search, T[] array) { for (T element : array) { if (element.equals(search)) { return true; } } return false; } } 

Y el principal para probarlo

 package arrays.duplicates; import java.util.Arrays; public class TestArrayDuplicates { public static void main(String[] args) { Integer[] array = {1, 1, 2, 2, 3, 3, 3, 3, 4}; testArrayDuplicatesRemover(array); } private static void testArrayDuplicatesRemover(Integer[] array) { final Integer[] expectedResult = {1, 2, 3, 4}; Integer[] arrayWithoutDuplicates = ArrayDuplicatesRemover.removeDuplicates(array, Integer.class); System.out.println("Array without duplicates is supposed to be: " + Arrays.toString(expectedResult)); System.out.println("Array without duplicates currently is: " + Arrays.toString(arrayWithoutDuplicates)); System.out.println("Is test passed ok?: " + (Arrays.equals(arrayWithoutDuplicates, expectedResult) ? "YES" : "NO")); } } 

Y el resultado:

 Array without duplicates is supposed to be: [1, 2, 3, 4] Array without duplicates currently is: [1, 2, 3, 4] Is test passed ok?: YES 

¿Qué tal este, solo para una matriz ordenada de números, para imprimir una matriz sin duplicados, sin usar Set u otras Colecciones, solo Array:

  public static int[] removeDuplicates(int[] array) { int[] nums =new int[array.length]; int addedNum = 0; int j=0; for(int i=0;i 

Matriz de 1040 números duplicados procesados ​​en 33020 nanosegundos ( 0.033020 milisegundos ).

De acuerdo, entonces no puedes usar Set u otras colecciones. Una solución que no veo aquí hasta ahora se basa en el uso de un filtro Bloom , que esencialmente es una matriz de bits, por lo que tal vez eso satisfaga sus requisitos.

El filtro Bloom es una técnica encantadora y muy práctica, rápida y eficiente desde el punto de vista del espacio, que se puede usar para verificar rápidamente la existencia de un elemento en un conjunto sin almacenar el conjunto o los elementos. Tiene una tasa de falsos positivos (típicamente pequeña), pero ninguna tasa de falsos negativos. En otras palabras, para su pregunta, si un filtro Bloom le dice que un elemento no se ha visto hasta el momento, puede estar seguro de que no lo ha hecho. Pero si dice que se ha visto un elemento, realmente debe verificarlo. Esto aún ahorra mucho tiempo si no hay demasiados duplicados en su lista (para ellos, no hay bucle que hacer, excepto en el pequeño caso de probabilidad de un falso positivo – típicamente elige esta tasa en función de la cantidad espacio que está dispuesto a dar al filtro Bloom (regla general: menos de 10 bits por elemento único para una tasa de falsos positivos del 1%).

Hay muchas implementaciones de filtros Bloom, ver, por ejemplo, aquí o aquí , así que no lo repetiré en esta respuesta. Supongamos la API descrita en esa última referencia, en particular, la descripción de put(E e) :

true si los bits del filtro Bloom cambian como resultado de esta operación. Si los bits cambiaron, esta es definitivamente la primera vez que se ha agregado un objeto al filtro. Si los bits no han cambiado, esta podría ser la primera vez que se ha agregado un objeto al filtro. (…)

Una implementación usando un filtro Bloom así sería:

 public static int[] removeDuplicates(int[] arr) { ArrayList out = new ArrayList<>(); int n = arr.length; BloomFilter bf = new BloomFilter<>(...); // decide how many bits and how many hash functions to use (compromise between space and false positive rate) for (int e : arr) { boolean might_contain = !bf.put(e); boolean found = false; if (might_contain) { // check if false positive for (int u : out) { if (u == e) { found = true; break; } } } if (!found) { out.add(e); } } return out.stream().mapToInt(i -> i).toArray(); } 

Obviamente, si puede modificar la matriz entrante en su lugar, entonces no hay necesidad de una ArrayList : al final, cuando conoce la cantidad real de elementos únicos, simplemente arraycopy() .

Por favor, chequee esto. Funcionará para la matriz clasificada / no ordenada. La complejidad es O (n ^ 2) igual que sort de burbuja. Sí, la complejidad se puede mejorar aún más con la primera clasificación y luego la búsqueda binaria. Pero esto es lo suficientemente simple como para trabajar en todos los casos, excepto en el elemento negativo (-1). Esto también se puede cambiar usando un valor entero grande en lugar de -1.

 void remove_duplicates(int *A, int N) { int i,j; for (i=1; i 

¿Por qué todas las personas no revisan estas líneas a continuación?

Necesito escribir mi propia implementación, no usar Set, HashSet, etc. O cualquier otra herramienta como iteradores. Simplemente una matriz para eliminar duplicados.

Estoy publicando una implementación muy simple con el cuidado de la línea anterior.

 public class RemoveDuplicates { public static void main(String[] args) { int[] arr = { 1, 2, 3, 4, 2, 3, 1 }; // input array int len = arr.length; for (int i = 0; i < arr.length; i++) { for (int j = i + 1; j < len; j++) { if (arr[i] == arr[j]) { while (j < (len) - 1) { arr[j] = arr[j - 1]; j++; } len--; } } } for (int i = 0; i < len; i++) { System.out.print(" " +arr[i]); } } } 

Entrada: 1, 2, 3, 4, 2, 3, 1

Salida: 1 2 3 4

Aquí está mi solución. La complejidad del tiempo es o (n ^ 2)

 public String removeDuplicates(char[] arr) { StringBuilder sb = new StringBuilder(); if (arr == null) return null; int len = arr.length; if (arr.length < 2) return sb.append(arr[0]).toString(); for (int i = 0; i < len; i++) { for (int j = i + 1; j < len; j++) { if (arr[i] == arr[j]) { arr[j] = 0; } } if (arr[i] != 0) sb.append(arr[i]); } return sb.toString().trim(); } 
 public void removeDup(){ String[] arr = {"1","1","2","3","3"}; boolean exists = false; String[] arr2 = new String[arr.length]; int count1 = 0; for(int loop=0;loop 
  package javaa; public class UniqueElementinAnArray { public static void main(String[] args) { int[] a = {10,10,10,10,10,100}; int[] output = new int[a.length]; int count = 0; int num = 0; //Iterate over an array for(int i=0; i 

}

Esta es una pregunta de la entrevista: eliminar duplicados de una matriz. No utilizaré ningún conjunto o colección. La solución completa es:

 public class Test4 { public static void main(String[] args) { int a[] = {1, 2, 2, 3, 3, 3, 6,6,6,6,6,66,7,65}; int newlength = lengthofarraywithoutduplicates(a); for(int i = 0 ; i < newlength ;i++) { System.out.println(a[i]); }//for }//main private static int lengthofarraywithoutduplicates(int[] a) { int count = 1 ; for (int i = 1; i < a.length; i++) { int ch = a[i]; if(ch != a[i-1]) { a[count++] = ch; }//if }//for return count; }//fix }//end1 
 public static int[] removeDuplicates(int[] arr) { int end = arr.length; HashSet set = new HashSet(end); for(int i = 0 ; i < end ; i++){ set.add(arr[i]); } return set.toArray(); } 

Aquí hay una manera más simple y mejor de hacer esto usando listas de arreglos:

 public static final  ArrayList removeDuplicates(ArrayList in){ ArrayList out = new ArrayList(); for(T t : in) if(!out.contains(t)) out.add(t); return out; } 
 public class RemoveDuplicates { public Integer[] returnUniqueNumbers(Integer[] original, Integer[] uniqueNumbers) { int k = 0; for (int j = original.length - 1; j >= 0; j--) { boolean present = false; for (Integer u : uniqueNumbers) { if (u != null){ if(u.equals(original[j])) { present = true; }} } if (present == false) { uniqueNumbers[k] = original[j]; k++; } } return uniqueNumbers; } public static void main(String args[]) { RemoveDuplicates removeDup = new RemoveDuplicates(); Integer[] original = { 10, 20, 40, 30, 50, 40, 30, 20, 10, 50, 50, 50,20,30,10,40 }; Integer[] finalValue = new Integer[original.length + 1]; // method to return unique values Integer[] unique = removeDup.returnUniqueNumbers(original, finalValue); // iterate to return unique values for (Integer u : unique) { if (u != null) { System.out.println("unique value : " + u); } } }} 

Este código maneja una matriz sin clasificar que contiene múltiples duplicados para el mismo valor y devuelve elementos únicos.