Java implementa algoritmos de classificação comumente usados (orçamento de bolha, classificação de seleção, classificação de inserção, classificação de Hill)

Algoritmos de Ordenação Comuns

Complexidade de tempo do algoritmo de classificação

Algoritmo de Ordenação	Tempo médio	pior hora	estabilidade	complexidade do espaço	Observação
Tipo de bolha	O(n2)	O(n2)	estabilizar	O(1)	melhor quando n é pequeno
tipo de troca	O(n2)	O(n2)	instável	O(1) n	bom quando pequeno
tipo de seleção	O(n2)	O(n2)	instável	O(1) n	bom quando pequeno
tipo de inserção	O(n2)	O(n2)	estabilizar	O(1)	principalmente em ordem
classificação radix	O(n*k)	O(n*k)	estabilizar	Sobre)	Array bidimensional (balde), array unidimensional (posição do primeiro elemento no balde)
Tipo de colina	O(nlogn)	O(ns)(1<s<2)	instável	O(1)	s é o grupo selecionado
ordenação rápida	O(nlogn)	O(n2)	instável	O(logn)	melhor quando n é maior
classificação de mesclagem	O(nlogn)	O(nlogn)	estabilizar	O(1)	melhor quando n é maior
tipo de pilha	O(nlogn)	O(nlogn)	instável	O(1)	melhor quando n é maior

Tipo de bolha

1. Introdução

Bubble Sort é um algoritmo de classificação relativamente simples no campo da ciência da computação.
Ele visita repetidamente a coluna de elementos a serem classificados, compara dois elementos adjacentes por vez e os troca se a ordem (como de grande para pequeno, letra inicial de Z para A) estiver errada. O trabalho de visita de elementos é repetido até que não haja necessidade de troca de elementos adjacentes, ou seja, a coluna de elementos esteja ordenada.
O nome desse algoritmo vem do fato de que os elementos menores irão "flutuar" lentamente para o topo da sequência (em ordem crescente ou decrescente) por meio de troca, assim como as bolhas de dióxido de carbono em bebidas carbonatadas acabarão flutuando para o topo , daí o nome "borbulhar". Classificar".

2. Análise do Pensamento

• Compare dois elementos adjacentes, se o primeiro for maior que o segundo, troque as posições
• Efetue esta operação em cada elemento subseqüente até que o último finalize o primeiro ciclo, de forma que o último elemento deve sermaior elemento, portanto, não é necessário comparar o último elemento nas comparações de loop subsequentes
• Repita as etapas acima para excluiro último elemento do loop anterior,entãolaço internoserá cada vez menos
• até que não haja pares de números para comparar
• laço externoO número de vezes é o número de elementos da matriz - 1 , e == o número de comparações de loop interno está ficando cada vez menor –
• Otimização: se em um determinadoOs elementos não são trocados no loop externo, prova que já é um array ordenado, então o loop pode ser encerrado

3. Diagrama

1. O primeiro ciclo (amarelo representa a posição de troca, vermelho representa a posição final)

2. O segundo ciclo

3. O terceiro ciclo

4. O quarto ciclo

loop final

4. Implementação do código

/**
 * 冒泡排序
 * @author 尹稳健~
 * @version 1.0
 * @time 2022/9/7
 */
public class Bubbling {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    3,9,-1,7,21};
        // 外层循环次数为数组的长度-1
        for (int i = 0; i < arr.length - 1; i++) {
    
    
            // 内层循环次数，每次都会减少
            for (int j = 0; j < arr.length - 1 - i; j++) {
    
    
                // 交换位置
                if (arr[j] > arr[j+1]){
    
    
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }

        // 打印
        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.print(arr[i]+" ");
        }
    }

}

Otimização: Se for constatado que a posição dos elementos do array não mudou após o término de um determinado loop externo, então o loop termina e já é um array ordenado

código:

/**
 * 冒泡排序
 * @author 尹稳健~
 * @version 1.0
 * @time 2022/9/7
 */
public class Bubbling {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    3,9,-1,7,21};
        // 外层循环次数为数组的长度-1
        for (int i = 0; i < arr.length - 1; i++) {
    
    
            // 如果内层循环没有交换位置，那么已经是有序数组，结束循环
            boolean flag = true;
            // 内层循环次数，每次都会减少
            for (int j = 0; j < arr.length - 1 - i; j++) {
    
    
                // 交换位置
                if (arr[j] > arr[j+1]){
    
    
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = false;
                }
            }
            if (flag){
    
    
                break;
            }
        }

        // 打印
        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.print(arr[i]+" ");
        }
    }

}

tipo de seleção

1. Introdução

A classificação por seleção é um algoritmo de classificação simples e intuitivo. Seu princípio de funcionamento é: selecione o menor (ou maior) elemento dos elementos de dados a serem classificados pela primeira vez, armazene-o na posição inicial da sequência e, em seguida, encontre o menor (maior) elemento do restante elemento não classificado e colocá-lo no final da sequência classificada. E assim por diante, até que o número de todos os elementos de dados a serem classificados seja zero. A classificação por seleção é um método de classificação instável.

2. Análise do Pensamento

2.1 Trocar dados pela primeira vez

/**
 * @author 尹稳健~
 * @version 1.0
 * @time 2022/9/7
 */
public class Deduction {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    8,3,2,1,7,4,6,5};
        // 记录最小数的下标
        int min;
        // 假设min=0开始
        min = 0;
        // 既然我们都假设下标为0的是最小，那么就从他后面开始比较
        for (int i = 1; i < arr.length; i++) {
    
    
            // 如果后面的元素中有小于的元素，记住的他下标
            if (arr[min] > arr[i]){
    
    
                min = i;
            }
        }
        // 交换
        int temp = arr[0];
        arr[0] = arr[min];
        arr[min] = temp;

        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.print(arr[i] + " ");
        }

        // 打印获取到 1 3 2 8 7 4 6 5 

    }
}

2.2 O segundo tempo começa em i+1

/**
 * @author 尹稳健~
 * @version 1.0
 * @time 2022/9/7
 */
public class Deduction {
    
    
    public static void main(String[] args) {
    
    
//        int[] arr = {8,3,2,1,7,4,6,5};
        int[] arr = {
    
    1,3,2,8,7,4,6,5};
        // 记录最小数的下标
        int min;
        // 假设min=1开始
        min = 1;
        // 既然我们都假设下标为1的是最小，那么就从他后面开始比较
        for (int i = 2; i < arr.length; i++) {
    
    
            // 如果后面的元素中有小于的元素，记住的他下标
            if (arr[min] > arr[i]){
    
    
                min = i;
            }
        }
        // 交换
        int temp = arr[1];
        arr[1] = arr[min];
        arr[min] = temp;

        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.print(arr[i] + " ");
        }

        // 打印获取到 1 2 3 8 7 4 6 5 

    }
}

e assim por diante

2.3 Resumo

• i começa de 0, assumindomin representa o índice do valor mínimo, assumindo inicialmentemin = eu, EntãoEncontre o subscrito do menor elemento na seguinte matriz, deixe min = minIndex, posições de troca,Observe que ao procurar o índice mínimo subscrito, as posições de outros elementos não podem ser movidas
• Então o array anda para trás, pois o primeiro número já é o menor número, não há necessidade de compará-lo, partindo de i+1
• Repita as etapas acima até que a classificação termine
• É necessário um percurso total do comprimento da matriz - 1 vez.

3. Diagrama

4. Implementação do código

/**
 * 选择排序
 * @author 尹稳健~
 * @version 1.0
 * @time 2022/9/7
 */
public class Choice {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    8,3,2,1,7,4,6,5};
        // 记录最小数的下标
        int min;
        // 外层循环次数为数组长度 - 1
        for (int i = 0; i < arr.length - 1; i++) {
    
    
            min = i;
            // 内层循环每次都是从i+1开始
            for (int j = i+1; j < arr.length; j++) {
    
    
                // 找出最小数的下标
                if (arr[min] > arr[j]){
    
    
                    min = j;
                }
            }
            // 如果不是同一个数，那么就交换位置
            if (min != i){
    
    
                int temp = arr[i];
                arr[i] = arr[min];
                arr[min] = temp;
            }
        }
        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.print(arr[i]+" ");
        }
    }
}

tipo de inserção

1. Introdução

A classificação por inserção também é geralmente chamada de classificação por inserção direta. É um algoritmo eficiente para ordenar um pequeno número de elementos. A classificação por inserção é o método de classificação mais simples, sua ideia básica é inserir um registro emna lista ordenada ordenada, de modo a criar uma nova lista ordenada com o número de registros incrementado em 1. No processo de implementação, um loop de camada dupla é usado. O loop externo procura todos os elementos, exceto o primeiro elemento, e o loop interno procura a posição a ser inserida na lista ordenada na frente do elemento atual e o move .

2. Análise do Pensamento

• porque a matriz originalprimeiro elementocomoo primeiro elemento de uma lista ordenada, então comece diretamente do elemento com índice 1, quando 1 é inserido como um elemento para comparar com o último elemento na lista ordenada
• seinserir elemento menor que, então na lista ordenadaO último elemento será deslocado um bit para trás, até que seja encontrada uma posição na lista ordenada em que o elemento não seja maior que o elemento inserido, ouíndice menor que 0, finalize a comparação
• Em seguida, atribua o elemento inserido

3. Diagrama

Observe que a matriz vermelha aqui já representa um elemento de lista ordenado

3.1 Primeira rodada

3.2 Segundo turno

3.3 A terceira rodada

3.4 Quarta rodada

4. Implementação do código

/**
 * 插入排序
 * @author 尹稳健~
 * @version 1.0
 * @time 2022/9/9
 */
public class InsertSorted {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    3, 1, 6, 10, 2};

        for (int i = 1; i < arr.length; i++) {
    
    
            // 保留即将插入元素的值
            int insertValue = arr[i];
            // 当前索引
            int index = i;
            // 1.如果索引大于0，说明还没遍历完
            // 2.如果插入的值小于有序列表中的值，那么久有序列表中大于插入元素的元素，就要后移
            while (index > 0 && insertValue < arr[index-1]){
    
    
                arr[index] = arr[index-1];
                index --;
            }
            // 直到找到插入元素不大于有序列表中元素的位置
            arr[index] = insertValue;

        }
		// 打印
        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.print(arr[i] + " ");
        }

    }
}

---

Tipo de colina

1. Introdução

O Shell's Sort é um tipo de classificação por inserção, também conhecido como "Classificação por incremento decrescente", que é uma versão mais eficiente e aprimorada do algoritmo de classificação por inserção direta. Hill sort é um algoritmo de ordenação instável.
Hill sorting é agrupar os registros por um certo incremento do subscrito e usar o algoritmo de classificação por inserção direta para classificar cada grupo; à medida que o incremento diminui gradualmente, cada grupo contém mais e mais palavras-chave. Quando o incremento é reduzido para 1, o algoritmo termina quando todos os dados acabam de ser divididos em um grupo.

2. Análise do Pensamento

• Selecione uma sequência incremental t1 (geralmente comprimento de matriz/2), t2 (geralmente um comprimento de grupo/2), ..., tk, onde ti > tj, tk = 1;
• De acordo com o número de sequência incremental k, classifique a sequência k vezes;
• Para cada ordenação, de acordo com o incremento correspondente ti, a coluna a ser ordenada é dividida em várias subsequências de comprimento m, e a ordenação por inserção direta é realizada em cada sublista respectivamente. Somente quando o fator de incremento é 1, toda a sequência é tratada como uma tabela e o comprimento da tabela é o comprimento de toda a sequência.

3. Diagrama

3.1 Primeira rodada

O incremento é 3, e a comparação começa diretamente de arr[3], e verifica-se que arr[3] > arr[0], não há necessidade de mudar a posição, e arr[4] < arr[1] precisa mudar a posição, então

continue Compare

Até arr[6]<arr[3], troque as posições

e então descobrimos que arr[3] pode ser comparado com arr[0] porque index-gap >= 0 pode continuar comparando

3.2 Segundo turno

Comece comparando de arr[1] e compare para trás um por um até arr[6] < arr[5]

Depois de trocar as posições, compare arr[5] com arr[4] e troque as posições

Terminar

4. Implementação do código

/**
 * 希尔排序
 * @author 尹稳健~
 * @version 1.0
 * @time 2022/9/9
 */
public class ShellInsert {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    23,34,21,31,18,98,10};
        // 增量
        int gap = arr.length/2;
        // 只要增量大于等于1就继续分组
        while (gap >= 1){
    
    

            // 从索引=增量开始，依次往后
            for (int i = gap; i < arr.length; i++) {
    
    
                // 定义一个变量，防止下面代码影响原 i 的值
                int j = i;
                // 只有 arr[j] < arr[j-gap] 交换位置 ，而且可能一次不一定能比较完，需要多次比较 j-gap >= 0
                while (j-gap >= 0 && arr[j] < arr[j-gap]){
    
    
                    // 交换
                    int temp = arr[j];
                    arr[j] = arr[j-gap];
                    arr[j-gap] = temp;
                    // 假设 j = 6 时，可以多次执行
                    j -= gap;
                }
            }

            // 控制增量
            gap /= 2;

        }

        // 打印
        for (int i = 0; i < arr.length; i++) {
    
    
            System.out.print(arr[i]+" ");
        }

    }
}