[Estrutura e algoritmo de dados JS] Implementação de algoritmos de ordenação por borbulhamento, seleção e inserção

Prefácio

Uma classe de lista foi criada para o algoritmo de classificação: [estrutura de dados JS] Encapsulação da lista de algoritmos de classificação

Vamos aprender como implementar vários algoritmos de classificação comuns juntos!

texto

1. Classificação de bolha

O algoritmo de classificação mais básico e simples.

A ideia principal

• A primeira etapa é comparar os elementos adjacentes. Se o número à esquerda for maior do que o número à direita, troque os dois.
• A segunda etapa é mover para a direita e executar a primeira operação em cada par de elementos adjacentes. Até que o último par de operações na lista seja concluído, é finalmente determinado que o último elemento é o valor máximo.
• Na terceira parte, repita as operações da primeira e segunda etapas, reduzindo sucessivamente o número de deslocamentos à direita até que não haja nenhum par de elementos para comparar.

Para o seguinte sem lista, nós o classificamos. Implementação do código do

efeito de animação Se você precisar usar dois números para trocar, chame o método:

// 交换两个数
ArrayList.prototype.swap = function (a, b) {
    
    
    var temp = this.array[a];
    this.array[a] = this.array[b];
    this.array[b] = temp;
}

Algoritmo de classificação de bolha

// 冒泡排序
ArrayList.prototype.bubbleSort = function () {
    
    
    // 1.获取数组的长度
    var length = this.array.length;
    // 第一次： i = 0； 比较0 和1 的位置的两个数据，如果0位置的数据比1位置的数据大，则交换
    // 最后一次： i = length - 2 , 比较的是length - 2 和length - 1的两个数
    for (var i = length - 1; i > 0; i--) {
    
    
        for (var j = 0; j < i; j++) {
    
    
            if (this.array[j] > this.array[j + 1]) {
    
    
                // 2.交换两个数
                this.swap(j, j + 1);
            }
        }
    }
}

A eficiência da classificação
por bolha Para o exemplo acima, podemos saber que nos 6 dados, o número total de vezes que comparamos é:
5 + 4 + 3 + 2 + 1 (vezes)
Então, para o número de N, podemos deduzir :
(N-1) + (N-2) + (N-3) + ... + 1 = N * (N + 1) / 2 (vezes)
Então, na grande notação O anterior, podemos obter a grande notação O para classificação por bolha é O (N ² )

A complexidade do tempo é O (N ² )

A otimização da
classificação por bolha requer um total de comparações N * (N + 1) / 2 (vezes). No pior caso, N * (N + 1) / 2 (vezes) precisa ser trocado. Considere aqui, no final posição antes de determinar a posição do período de troca é realmente desnecessário e, portanto, precisa reduzir os tempos de comutação .

2. Escolha a classificação

O tipo de seleção é um aprimoramento do tipo de bolha, principalmente para reduzir o número de trocas, pois nem toda troca é necessária, ela reduz o número de trocas de N ² para N, mas o número de comparações ainda é N ² Vezes.

A ideia principal

• A primeira etapa é percorrer a lista inteira e extrair o maior (ou menor) elemento dela e colocá-lo no topo da lista não classificada;
• A segunda etapa é extrair o maior (ou menor) elemento da lista não classificada restante e colocá-lo no final da lista classificada.
• Na terceira parte, repita a operação da segunda etapa, reduzindo sucessivamente o intervalo de extração do maior valor até o último dígito da lista não classificada.

Selecione o algoritmo de classificação

// 选择排序
ArrayList.prototype.selectSort = function () {
    
    
    // 1. 获取数组的长度
    var length = this.array.length,
    min;
    // 2.每一次减少提取最小值的范围，直到未排序序列的最后一个元素。
    for (var i = 0; i < length - 1; i++) {
    
    
        min = i;
        // 第一次：遍历整个数组，选出最小的元素。
        // 第n次：剩下最后一个元素。
        for (var j = min; j < length; j++) {
    
    
            if (this.array[min] > this.array[j]) {
    
    
                min = j;
            }
        }
        // 将最小的数放到已排序序列的末尾
        this.swap(min, i);
    }
}

A eficiência da classificação seletiva é a
mesma da classificação por bolhas. Em seu pior caso, o número de comparações necessárias também é N * (N + 1) / 2 (vezes), mas o número de trocas é reduzido, então é geralmente considerado que a classificação seletiva está em execução. A eficiência é maior do que a classificação por bolha.

A complexidade do tempo é O (N ² )

Otimização A
seleção e classificação requerem um total de N * (N + 1) / 2 comparações e o número de comparações deve ser reduzido .

3. Classificação de inserção

A classificação por inserção é a mais eficiente da classificação simples (bolhas, seleção, inserção).
Antes de entrar na classificação avançada, a classificação por inserção é a base, e entender que a classificação por inserção é de grande ajuda para entender a classificação avançada.
A ideia central da classificação por inserção é a ordem parcial

O que é pedido parcial?
Por exemplo, selecionamos uma pessoa da equipe como o jogador marcado;
então, todos os jogadores à esquerda do jogador marcado já estão em ordem, ou seja, no processo de enfileiramento, algumas pessoas são classificadas, e outras estão Não classificado.

A ideia principal

• A primeira etapa é tratar o primeiro elemento como uma lista ordenada e a lista restante como uma lista não ordenada;
• A segunda etapa é começar com o primeiro elemento na lista não ordenada e inseri-lo na posição correspondente da lista ordenada. A comparação durante o período é a última da lista ordenada e a primeira da lista não ordenada, para a ordem da lista ordenada. À esquerda, execute uma comparação sequencial para inserção.

Ainda é o exemplo acima para classificação de inserção ,

animação de classificação de inserção

Algoritmo de classificação por inserção

// 插入排序
ArrayList.prototype.insertionSort = function(){
    
    
    // 1. 获取数组的长度
    var length = this.array.length,
    temp,j;

    // 2. 外层循环，从第2个元素（索引为1）开始获取数据，将它作为标记，向前面局部有序的列表中插入
    for(var i = 1; i < length; i++){
    
    
        // 3. 内层循环，将标记元素和前面的数据依次进行比较
        temp = this.array[i];
        j = i;
        // 4. 只要大于标记元素的值，就继续往前面找，在列表范围内直到找到不比标记元素的值大的位置。
        while(this.array[j - 1] > temp && j > 0){
    
    
            this.array[j] = this.array[j - 1];
            j--;
        }

        // 5. 将标记元素插入
        this.array[j] = temp;
    }
}

A eficiência da ordenação por inserção
Embora o número de comparações e trocas no pior caso seja N * (N-1) / 2 (vezes);
no entanto, o número médio de vezes é apenas metade do total de itens de dados (N * (N -1) / 4) Comparações e trocas são necessárias, ou seja, a soma dos tempos de comparação e troca de classificação por inserção é igual ao número de comparações de classificação
por seleção; portanto, o número de comparações e trocas de classificação por inserção é geralmente considerada melhor do que classificação por bolha e seleção As classificações são pequenas, portanto, é considerado que a classificação por inserção é mais eficiente em execução do que classificação por bolha e classificação por seleção.

A complexidade do tempo é O (N ² )

Otimização
para algoritmos avançados!

Resumindo

Os algoritmos de classificação podem ser usados ​​em muitas situações. Por exemplo, o preço da lista é classificado em ordem crescente ou decrescente, ou pode ser classificado por vendas ...
Compreender algoritmos de classificação simples é o pré-requisito para compreender algoritmos de classificação avançados e aprender algoritmos de classificação avançados devem ser A incompletude é demais para suportar, então estabeleça a base para inserir o algoritmo de classificação avançada! ---- "[estrutura de dados e algoritmo JS] Implementação de classificação de Hill e algoritmos de classificação rápida (a ser atualizado)