Programa Java para imprimir todos los números repetidos con frecuencia en una array

La frecuencia de un elemento en una array es el recuento de la aparición de ese elemento en particular en toda la array. Dada una array que puede contener duplicados, imprima todos los elementos repetidos/duplicados y sus frecuencias.

A continuación se presenta la discusión de este programa por dos enfoques:

1. Usando una array de contadores : Manteniendo una array separada para mantener el conteo de cada elemento.
2. Uso de HashMap : al actualizar el recuento de cada elemento de array en HashMap<Integer, Integer>.

Ejemplo :

Input :  arr[] = {1, 2, 2, 1, 1, 2, 5, 2}
Output : 1 3
         2 4
// here we will not print 5 as it is not repeated 

Input : arr[] = {1, 2, 3}
Output : NULL

// output will be NULL as no element is repeated.

Método 1: (usando una array de contadores)

Explicación :

• La array se puede ordenar y no ordenar.
• Primero, cuente todos los números en la array usando otra array.
• A sea una array, A[ ] = {1, 6 ,4 ,6, 4, 8, 2, 4, 1, 1}
• B sea una array de contador B[x] = {0}, donde x = max en la array A «para el ejemplo anterior 8».
• En un bucle for, inicializado con i. Aumente el valor en la array de contadores para cada elemento de la array A.
• B [ A [i] ]++; esto dará una array de contadores como

Array B después de contar elementos

• Finalmente imprima el índice de B con su elemento siempre que el elemento sea mayor que 1.

// Java program to count the frequency of
// elements in an array by using an extra
// counter array of size equal to the maximum
// element of an array
  
import java.io.*;
  
class GFG {
    public static void main(String[] args)
    {
  
        int A[] = { 1, 6, 4, 6, 4, 8, 2, 4, 1, 1 };
  
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < A.length; i++) {
            if (A[i] > max)
                max = A[i];
        }
  
        int B[] = new int[max + 1];
        for (int i = 0; i < A.length; i++) {
  
            // increment in array B for every integer
            // in A.
            B[A[i]]++;
        }
        for (int i = 0; i <= max; i++) {
            // output only if element is more than
            // 1 time in array A.
            if (B[i] > 1)
                System.out.println(i + "-" + B[i]);
        }
    }
}

Producción:

1-3
4-3
6-2

El enfoque anterior puede consumir más espacio que es igual a la restricción máxima del elemento de array

Complejidad de tiempo: O(n)

Complejidad espacial: O(K) donde K es el máximo elemento/restricción de una array

Método 2: (usando HashMap)

• Es un método simple y tiene una lógica base, también puede hacerlo usando un Mapa desordenado.
• El mapa ahorrará mucho espacio y tiempo.

// Java program to maintain
// the count of each element
// by using map.
import java.util.*;
  
class GFG {
  
    public static void main(String[] args)
    {
  
        int[] a = { 1, 6, 4, 6, 4, 8, 2, 4, 1, 1 };
        int n = a.length; // size of array
  
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < n; i++) {
  
            if (map.containsKey(a[i])) {
  
                // if element is already in map
                // then increase the value of element at
                // index by 1
  
                int c = map.get(a[i]);
                map.replace(a[i], c + 1);
            }
  
            // if element is not in map than assign it by 1.
            else
                map.put(a[i], 1);
        }
        for (Map.Entry<Integer, Integer> i :
             map.entrySet()) {
  
            // print only if count of element is greater
            // than 1.
            if (i.getValue() > 1)
                System.out.println(i.getKey() + " "
                                   + i.getValue());
  
            else
                continue;
        }
    }
}

1 3
4 3
6 2

Complejidad de tiempo: O(n)

Complejidad espacial: O(n)