Dirección del evento: Desafío de aprendizaje de 21 días de CSDN

prefacio

Muchas personas han oído hablar del algoritmo de clasificación clásico, y muchas personas pueden haberlo usado, pero también hay muchas personas que nunca han oído hablar de él. ¿por qué? Ahora que tenemos más y más marcos y paquetes dependientes, podremos usar la escena real de clasificación y encapsularla en una función como un negocio.Por lo tanto, algunas personas solo conocen la función pero no su lógica operativa.

Con base en lo anterior, para comprender mejor la lógica de operación de la función, resolví algunas reglas de operación del método de clasificación básico, así como algunos conocimientos personales, con la esperanza de brindarle alguna ayuda.

Este artículo cubrirá la ordenación por inserción.

tipo de inserción

La clasificación por inserción (InsertionSort) es un algoritmo de clasificación simple e intuitivo. Funciona mediante la construcción de una secuencia ordenada y, para los datos no clasificados, escanea de atrás hacia adelante en la secuencia ordenada, encuentra la posición correspondiente y la inserta.
La clasificación por inserción puede entenderse como jugar a las cartas o jugar al mahjong en la vida diaria, clasificando las cartas tocadas desordenadas en cartas ordenadas.

Principio de implementación del ordenamiento por inserción

De forma predeterminada, el primer elemento es una secuencia ordenada y los elementos desde el segundo elemento hasta el final son una secuencia desordenada;
Tome el siguiente elemento de la secuencia ordenada como valor objetivo y compare el valor objetivo con la secuencia ordenada;
El valor objetivo se compara con los elementos de secuencia ordenados;
Cuando el valor objetivo es mayor que el elemento de la secuencia ordenada, compárelo con el siguiente elemento;
Cuando el valor objetivo es menor o igual que el elemento de secuencia ordenado, inserte el valor objetivo en esta posición;
Repita los pasos 2 a 5;

el código


function insertionSort(array) {
    
    
  let length = array.length;
  let preIndex, current;
  // 从第二个数开始循环
  for (let i = 1; i < length; i++) {
    
    
    // 当前数的前一个index开始对比
    preIndex = i - 1;
    // 当前需要插入的数据，用current空间参数存起来
    current = array[i];
    // 进入二次循环，该循环用来对比排序完成的数与当前需要插入的数据
    while (preIndex >= 0 && current < array[preIndex]) {
    
    
      // 因为当前值已经被抽出，它的序号比需要对比的数的最大序列大1，所以当满足条件，可以把preIndex + 1的序列的值赋值为 // preIndex
      array[preIndex + 1] = array[preIndex];
      // 继续循环
      preIndex--;
    }
    array[preIndex + 1] = current; // 外层完成一次循环后，把找到的当前小于current 的前一位数替换成插入元素
  }
  console.log('insertionSort result:', array);
}

insertionSort([9, 1, 0, 2, 3, 8, 6, 3]);

valor de salida

Doble para escritura en bucle


function insertionSort2(array) {
    
    
  let length = array.length;
  let preIndex, current;
  // 从第二个数开始循环
  for (let i = 1; i < length; i++) {
    
    
    // 当前数的前一个index开始对比
    preIndex = i;
    // 当前需要插入的数据，用current空间参数存起来
    current = array[i];
    let twoCurrent;
    // 进入二次循环，该循环用来对比排序完成的数与当前需要插入的数据
    for (let j = i - 1; j >= 0; j--) {
    
    
      if (array[j] > current) {
    
    
        let temp = array[preIndex];
        array[preIndex] = array[j];
        array[j] = temp;
        preIndex = j;
      } else {
    
    
        break;
      }
    }
  }
  console.log('insertionSort2 result:', array);
}

insertionSort2([9, 1, 0, 2, 3, 8, 6, 3]);

Ya sea que el valor de salida

se escriba en un tiempo o en un bucle for doble, se puede lograr el resultado final; pero la escritura del bucle for doble es más fácil de entender; por supuesto, al escribir códigos lógicos complejos, recuerde agregar los comentarios necesarios, de lo contrario hará que el lector se sienta muy angustiado;

la complejidad

Complejidad temporal: O(n^2)
Complejidad espacial: O(1)

mensaje

Hay muchos escenarios de aplicación para la clasificación por inserción, y las variantes incluyen la clasificación binaria. Solo una base sólida puede optimizarse mejor. ¡Vamos, todos!

Pensar es la escalera del progreso.

Clasificación de inserción de clasificación de algoritmo de javascript