Algoritmo de classificação de classificação de contagem (versão Java)

A classificação por contagem é um algoritmo de classificação que não se baseia em comparação. Sua vantagem é que, ao classificar inteiros dentro de um determinado intervalo, sua complexidade é Ο (n + k) (onde k é o intervalo de inteiros), que é mais rápido do que qualquer algoritmo de classificação por comparação. Claro, este é um algoritmo que sacrifica espaço por tempo.

Ideia básica

A ideia básica de contagem e classificação é: para cada elemento de entrada x, determine o número de elementos menor que x. Por exemplo, se houver 7 elementos menores que x, então x deve estar na 8ª posição de saída.

processo de trabalho

• Preparação:
  Matriz de entrada: array[1 ... n].
  Matriz de saída: result[1 ... n].
  Armazene temporariamente a matriz: countArray[0 ... k].
• Calcule arrayo número de cada elemento no countArrayarray e armazene-o no array: use arrayo valor do elemento no countArrayarray como o subscrito do array, e o elemento correspondente do array é +1 para arraycada ocorrência repetida do elemento do meio countArray.
• Calcule arrayo número menor que o elemento atual na countArraymatriz = a soma do elemento atual e o elemento anterior na matriz. E atualize os dados para a countArraymatriz
• De acordo com countArraya determinação, o elemento atual na matriz é menor do que o número arrayde elementos na matriz de resultposições de armazenamento na matriz.

Código

    /**
     * 计数排序
     * @param array 待排序数组
     * @param k 临时数组长度，取值为排序数组的最大值+1
     *          （此处是因为 array 中的元素被作为数组下标，所以数组长度为最大值+1）
     */
    private static void countSort(int[] array, int k) {
    
    
        //创建计数统计数组
        int[] countArray = new int[k];
        //计算 array 中每个元素的重复个数
        for (int i = 0; i < array.length; i++) {
    
    
            countArray[array[i]] += 1;
        }
        //计算数组中小于当前元素的元素个数
        for (int i = 0; i < k; i++) {
    
    
            if (i > 0) {
    
    
                countArray[i] = countArray[i] + countArray[i - 1];
            }
        }
        //结果输出数组
        int[] result = new int[array.length];
        //将 array 中的元素存放到 result 指定位置
        for (int i = array.length - 1; i >= 0; i--) {
    
    
            System.out.println("array:" + array[i] + " | countArray:" + countArray[array[i]]);
            //计算存放位置(小于当前元素的数量值-1即为数组下标)
            int pos = countArray[array[i]] -1;
            //根据计数统计数组将数组array中的元素存放到result数组中
            result[pos] = array[i];
            //小于当前元素的数量值-1
            countArray[array[i]] = pos;
        }
        
        System.out.println(Arrays.toString(result));

    }

Atualização tardia, haha. A classificação por contagem parece ser um algoritmo pouco usado, mas a ideia é relativamente simples em comparação com outra classificação por comparação e vale a pena aprender.