✅ Algoritmos de classificação JavaScript simples

Índice

Um algoritmo é, por definição, um conjunto ordenado (Isto é muito importante) de operações sistemáticas que nos permite fazer um cálculo para encontrar a solução de todos os problemas do mesmo tipo. Em outras palavras, é um conjunto de instruções que sempre segue o seguinte padrão:

Precisão: Você deve explicar de forma única e inequívoca cada etapa ou instrução.
Finito: O número de instruções a serem executadas deve ser limitado.
Definição: Os mesmos dados de entrada devem sempre fornecer as mesmas informações de saída.
Entrada: O número de elementos de entrada pode ser zero ou mais.
Resolução: Deve sempre produzir um resultado, que será o (s) dado (s) de saída.

Quando um algoritmo é implementado em uma determinada linguagem de programação, ele se torna um programa que pode ser executado em um computador, portanto, podemos dizer que um programa é um algoritmo ou conjunto de algoritmos escritos em uma linguagem específica para o computador usar. Neste caso, este programa é denominado algoritmo computacional. Por outro lado, se não precisa de um computador para funcionar, estamos falando de algoritmos não computacionais.

No nosso caso, vamos falar sobre algoritmos computacionais.

Sabendo o que é um algoritmo, vamos nos concentrar nos algoritmos de classificação, ou o que é o mesmo, o algoritmo que serve para classificar e retornar uma lista que foi inicialmente fornecida com elementos colocados aleatoriamente já ordenados.
O 3 algoritmos de classificação mais conhecidos são Bolha classificar ou classificar por bolha, Seleção classificar ou classificar por seleção e Inserção classificar ou classificar por inserção. Todos eles são considerados algoritmos ou métodos simples, pois são resolvidos por iteração ou repetição de até um número n de vezes.

1. Classificar por bolha ou classificar por bolhaTomando como exemplo um array com quatro valores, neste caso para simplificar quatro números, veremos como funciona o algoritmo.

Matriz = (4, 7, 8, 5, 9);

Queremos que você o retorne ordenado do maior para o menor, por exemplo, ou seja (9, 8, 7, 5, 4).

Para fazer isso, a primeira coisa que temos que fazer é perguntar os dois primeiros valores, qual é o maior. Caso o segundo valor seja maior que o primeiro, como é o caso, devem ser trocados, por outro lado, se já estiverem encomendados, deixamos como estão.
Então, o mesmo processo teria que ser repetido com o segundo e o terceiro valores. Nesse caso, o terceiro valor é maior, então o trocaríamos, deixando nosso array = (7, 8, 4, 5, 9).
Em seguida, repetimos a etapa anterior com o terceiro e o quarto valores e, novamente, os trocamos. (7, 8, 5, 4, 9).
E, finalmente, após a primeira iteração seria: (7, 8, 5, 9, 4).
Ainda não está ordenado, porém conseguiu-se que o último elemento, o que fica à direita do todo, o 4, se ordenou como o menor número de todos.
Na próxima rodada para ordenar nosso array, não é mais necessário levar o último em consideração porque já sabemos que ele está ordenado, então compararíamos o primeiro e o segundo elemento, então o segundo e o terceiro elemento, e finalmente o terceiro e quarto elementos e a matriz permaneceria: (8, 7, 9, 5, 4).
Agora o último e o penúltimo elemento estão classificados.
Fazemos outra rodada comparando o primeiro e o segundo valores e, em seguida, o segundo e o terceiro e a matriz fica assim: (8, 9, 7, 5, 4).
Os últimos três elementos já estão ordenados, portanto, basta mais uma volta para deixar o array completamente ordenado: (9, 8, 7, 5, 4).

É assim que o algoritmo burburja, que é assim chamado porque em cada volta o último elemento sobe como uma bolha e é ordenado.

Agora implementado para JavaScript É muito simples:

bolha de função (meuVetor) {var tam = meuVetor.length; for (var temp = 1; temp <size; temp ++) {for (var left = 0; left <(size - temp); left ++) {var right = left + 1; if (myArray [left] <myArray [right] {sort (myArray, left, right);}}} return myArray;}

Passamos um array para nossa função e dentro dele a primeira coisa que fazemos é calcular seu tamanho, calcular o número de elementos no array.
Em seguida, criamos um loop externo que atravessa nosso array tantas vezes quanto os elementos têm menos um (já que são os tempos necessários para que seja totalmente ordenado).
Internamente, criamos outro loop que passa pelos valores comparando cada um com o próximo e se o da esquerda for menor que o da direita, ele os troca pela função de classificação que veremos a seguir.
Finalmente, ele retorna a matriz ordenada.

classificação de função (meuVetor, valor1, valor2) {var temp = meuVetor [valor1]; meuVetor [valor1] = meuVetor [valor2]; meuVetor [valor2] = temp; return myArray;}

onde valor1 é o índice do primeiro item a trocar e valor2 é o índice do segundo item a trocar.

2. Classificação de seleçãoO algoritmo que veremos a seguir não move os elementos um por um como na bolha um, mas primeiro percorre a matriz completa e, em seguida, seleciona o elemento correto para o posicionamento de acordo com os critérios que estamos seguindo (por exemplo, do mais alto para o mais baixo) e o coloca diretamente em sua posição, e é assim que o algoritmo recebe o seu nome, selecionando, pegando um elemento e movendo-o com um único movimento até sua posição correta.

No mesmo exemplo de antes de Array = (4, 7, 8, 5, 9) se quisermos ordená-lo do maior para o menor, por exemplo, primeiro selecionaríamos 9 e colocá-lo em primeiro lugar e 4 ocuparia o último posição (9, 7, 8, 5, 4). Na segunda rodada, ele selecionaria o 8 e o trocaria pelo 7 para permanecer na posição correta. Nas rodadas seguintes eu não modificaria nada, pois já foi pedido.

O código desse algoritmo seria o seguinte:

seleção de função (meuVetor) {var tam = meuVetor.length; para (var temp = 0; temp <tamanho -1; temp ++) {principal = temp; for (var check = temp + 1; check <size; check ++) {if (myArray [check] <myArray [major] {major = check;}} sort (myArray, major, check);} return myArray;}

O código funciona semelhante ao da bolha, mas o loop for externo passa pelos valores de 0 a N-2 (eles têm o mesmo número de etapas entre 1 e N-1 como na bolha, mas a operação é diferente ) operando diretamente sobre os elementos para colocá-los na posição correta em cada curva.
O número de voltas necessárias para que todos os elementos sejam ordenados é o mesmo da bolha N-1, pois a cada iteração deixamos um elemento colocado em seu lugar e aquele que podemos ignorar nas voltas seguintes.

No entanto, modificamos ligeiramente a função de classificação para salvar as etapas quando descobrimos que algum elemento já está ordenado:

função classificar (meuVetor, valor1, valor2) {if (valor1 == valor2) {retornar meuVetor; } var temp = meuVetor [valor1]; meuVetor [valor1] = meuVetor [valor2]; meuVetor [valor2] = temp; return myArray;}

Para conseguir isso, incluímos um loop if no qual ele verifica se os valores correspondem, ou seja, se eles já estão ordenados.

3. Classificação de inserçãoFinalmente, veremos o algoritmo mais eficiente dos três, pois nem sempre precisaremos de N-1 iterações para colocar nosso array, como veremos a seguir.

Este algoritmo de inserção funciona de forma semelhante a colocar uma mão de cartas em um jogo de pôquer à medida que as cartas são distribuídas.
Normalmente ordenamos as cartas por naipes e, dentro delas, por ordem crescente, da seguinte forma:
Primeiro é dada uma carta, um único elemento que é ordenado (por ser único). Então, quando há elementos “j” ordenados do menor para o maior, pegamos o elemento j + 1 e o comparamos com todos os elementos que já estão ordenados. Se encontrar um menor, já que os maiores terão deslocado para a direita, este elemento (j + 1) é inserido, deslocando-se para o resto.

O inserir algoritmo traduzido para Linguagem JavaScript é o seguinte:

inserção de função (meuVetor) {var tam = meuVetor.length, temp, local; para (var obj = 0; obj = 0 && meuArray [local]> temp; local--) {meuArray [local + 1] = meuArray [local]; } meuArray [local + 1] = temp; } return myArray;}