Classificação de colinas [algoritmo Java]

1. Conceito

A classificação por inserção também é uma classificação por inserção.É uma versão mais eficiente da classificação por inserção simples e também é chamada de classificação incremental por redução. A classificação Hill usa uma estratégia de agrupamento de salto na matriz, dividindo os elementos da matriz em vários grupos por meio de um determinado incremento e, em seguida, agrupa-os para classificação por inserção, depois reduz gradualmente o incremento e continua a realizar operações de classificação por inserção por grupo até que o incremento seja 1.

Recomendo um vídeo de seis minutos da Estação B. A animação PPT é muito bem feita e clara.

2. Ideias

① A classificação de colinas usa um método de agrupamento de salto. O que é um grupo de salto? Ou seja, os membros do mesmo grupo estão, na verdade, a alguma distância uns dos outros na sequência original. Eles são forçados a se separar para formar uma equipe, e a classificação por inserção é usada internamente para comparar tamanhos. A distância entre eles é igual. Chamamos essa distância de incremento. Como determinar o incremento? De modo geral, o valor do incremento inicial é metade do comprimento da sequência. Em seguida, calculamos o agrupamento com base no valor do incremento. Conforme mostrado na figura abaixo, o incremento é 5, então o índice 0 é um grupo com índice 5, índice 1 é um grupo com índice 6..., então Por analogia, as sequências são divididas em cinco grupos;

② Depois de ser dividido em grupos, a classificação por inserção é realizada dentro dos membros do grupo, mas a etapa de classificação por inserção aqui na verdade não é 1. Sabemos que a classificação por inserção original consiste em comparar os tamanhos e inserir passo a passo da direita para a esquerda, mas Hill A classificação é agrupada por salto. Embora você esteja atribuído à mesma equipe, não esqueça que seus próprios índices não estão conectados. O índice ainda é o índice da posição original. Portanto, ao inserir a classificação aqui, cada passo O comprimento deve ser o tamanho do incremento. Exceto pelos diferentes comprimentos do passo, outras ideias permanecem inalteradas;

③ Após a conclusão da primeira rodada de classificação, constatou-se que havia uma tendência geral na ordem das sequências como um todo, com as pequenas basicamente à esquerda e as grandes à direita. No entanto, este é o primeiro passo e ainda não está resolvido;

④ Inicie a próxima rodada de classificação. O valor do incremento no início de cada rodada deve ser metade do valor do incremento da rodada anterior. O princípio permanece o mesmo, agrupamento externo e classificação por inserção interna. Quando não será mais agrupado ou classificado? O valor incremental continua diminuindo pela metade e um dia será reduzido para 1. Quando chegar a 1, toda a sequência passará pela classificação de inserção mais básica. Sim, esta é a última etapa, então a condição de término é que o valor incremental comece ser menor que 1. Esta sequência de tempo já está completamente em ordem.

3. Implementação de código

import java.util.Arrays;

public class Test {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    2, 9, 3, 11, 7, 8, 4, 1, 6};
        int[] newArr = sort(arr);
        System.out.println(Arrays.toString(newArr));
    }
    public static int[] sort(int[] arr) {
    
    
        //控制增量值，初始值为序列长度的一半，每次减半，步长为0时停止
        for (int step = arr.length / 2; step > 0; step /= 2) {
    
    
            //控制待插入元素的位置，初始值为增量值
            for (int i = step; i < arr.length; i++) {
    
    
                //待插入元素
                int insertVal = arr[i];
                //待比较元素初始位置
                int index = i - step;
                //控制待比较元素的位置，初始值为待插入元素的位置减去增量值，即index
                while (index >= 0 && insertVal < arr[index]) {
    
    
                    //当前待比较元素向后移一位，这里的一位就是step长度
                    arr[index + step] = arr[index];
                    //指针向左挪动一位，继续跟下一个元素作比较
                    index -= step;
                }
                //退出循环后后，将待插入元素插入到index的下一位
                arr[index + step] = insertVal;
            }
        }
        return arr;
    }
}