Aquí se muestra un algoritmo de clasificación que se puede utilizar para una matriz de números enteros o estructuras codificadas por un número entero. Particularmente útil cuando el rango de números enteros está en el orden del tamaño de la entrada.

La idea principal es determinar la frecuencia de aparición de los números enteros y usarla para determinar el orden de clasificación.

Un ejemplo: digamos que obtenemos la matriz {1,3,1,2}.

Primero determine el rango de los números enteros, máximo y mínimo, 1 y 3 para esta entrada.

A continuación, cree una matriz, llámela matriz de recuentos, que es el tamaño del rango de enteros 1, por lo que 3 (3-1 1) en este caso.
Itere sobre la matriz de entrada, incrementando la entrada apropiada en recuentos. El recuento de un valor de entrada determinado se colocará en recuentos [valor - min]. Para la entrada dada, counts[0] mantendrá el recuento del valor 1.

Esto da como resultado la matriz de recuentos: {2,1,1}

Ahora determine los recuentos acumulativos, que son esencialmente recuentos[i] = recuentos[i-1] recuentos[i].

Esto da como resultado la matriz de recuentos acumulativos: {2,3,4}

Cree una matriz de salida para la entrada ordenada.

Ahora, itera sobre la entrada en orden inverso.

En cada paso, recupere el recuento acumulado del valor en la matriz de entrada. El valor se colocará en el índice de la matriz de salida correspondiente al recuento recuperado: 1. Luego, disminuya el valor del recuento acumulado.

En el primer paso, se recupera el valor 2 y se obtiene un recuento acumulado de 3. El valor debe colocarse en el índice 2 (3-1) en la salida.

En la siguiente iteración, el valor 1 y el recuento acumulado 2; entonces este '1' se coloca en el índice 1 (2-1) de la salida.

Continuando, el valor 3 y el conteo acumulado 4; colocándolo en el índice 3 de la salida.

Finalmente, el valor 1 por segunda vez y un conteo acumulado de 1 (ya que el conteo disminuyó la primera vez que se vio); entonces este '1' se coloca en el índice 0 de la salida.

, vea cómo la iteración inversa preserva el orden de elementos iguales haciendo que la clasificación sea 'estable'

La matriz ordenada resultante es {1,1,2,3}

func CountingSort(in []int) []int {
    // find the min/max values
    min := slices.Min(in)
    max := slices.Max(in)
    // create the count array
    counts := make([]int, max-min 1)
    for _, v := range in {
        counts[v-min]  
    }
    // determine cumulative counts
    for i := 1; i 



¿Se puede hacer más eficiente? Deje sus comentarios y sugerencias a continuación.

¡Gracias!

El código de esta publicación y todas las publicaciones de esta serie se pueden encontrar aquí