Tipo de inserción
La ordenación por inserción pertenece al método de ordenación interna . Para el elemento que se va a ordenar, busque la posición adecuada del elemento insertándolo para lograr el propósito de la ordenación.
Ordenar el pensamiento
Los n elementos a ordenar se consideran una lista ordenada y una lista desordenada . Al principio, la lista ordenada contiene solo un elemento y la lista desordenada contiene n-1 elementos . Cada vez que durante el proceso de clasificación, está desordenada. Tome el primer elemento de la tabla , compare su código de clasificación con el código de clasificación de los elementos de la lista ordenada e insértelo en la posición adecuada en la lista ordenada para convertirla en una nueva lista ordenada .
Diagrama
Por ejemplo, los datos del gráfico anterior son demasiado largos, tomemos un ejemplo simple, agregar una matriz es [17,3,25,14,20,9]
¿Cómo ordenar por inserción?
En primer lugar, el primer elemento 17 se considera una lista ordenada , luego el resto es una lista desordenada
La primera inserción : Inserte 3, que es menor que 17 en comparación con la lista ordenada. De acuerdo con nuestra regla de pequeño a grande, inserte antes de 17
Se convierte en [(3,17) 25,14,20,9]
La segunda inserción : Insertar 25, en comparación con la lista ordenada [3,17], es 17 más grande que la nuestra y se coloca después de 17
Se convierte en [(3,17,25) 14,20,9]
La tercera inserción : inserte 14, compare con la lista ordenada (3,17,25), es menor que 25, mira hacia adelante, menor que 17, y luego hacia adelante, mayor que 3, entre 3,17. Insertar como [(3,14,17,25) 20,9]
Y así sucesivamente , hasta que no haya datos en la lista desordenada.
Total Tiempo total n-1 para ser insertado
Escuche la pregunta:
HKUST tiene un estudiante de residencia, las calificaciones son: 101,34,119,1
Utilice la ordenación por inserción para ordenar sus puntuaciones de pequeñas a grandes
Código
package com.wang.sort;
import java.util.Arrays;
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/24 16:05
* @Description TODO
* @pojectname 插入排序算法
*/
public class InsertSort {
public static void main(String[] args) {
int[] arr = {
101,34,119,1};
insertSort(arr);
}
//插入排序
//逐步推到
//第一次插入101,34,119,1====>34,101,119,1
public static void insertSort(int[] arr){
//定义待插入的数 34是下标为0的元素
int insertValue = arr[1];
int insertIndex = 1-1;//跟谁比较，跟前面的数比较
//给insertValue找到插入位置
while (insertIndex >=0 && insertValue <arr[insertIndex]){
//insertIndex >=0保证我们找位置的时候不越界
//insertValue <arr[insertIndex]==》说明我们还没找到位置
//没有找到位置，说明我们的insertIndex代表的值大，往后面走
arr[insertIndex+1] = arr[insertIndex];
//数组变成了 101,101,119,1
//我们的34被保存到了insertValue中
insertIndex--;
}
//当退出while循环时，位置找到
arr[insertIndex+1] = insertValue;
System.out.println("第一次插入后的数组:"+ Arrays.toString(arr
));
//第二轮
insertValue = arr[2];
insertIndex = 2-1;
while (insertIndex >=0 && insertValue <arr[insertIndex]){
//insertIndex >=0保证我们找位置的时候不越界
//insertValue <arr[insertIndex]==》说明我们还没找到位置
//没有找到位置，说明我们的insertIndex代表的值大，往后面走
arr[insertIndex+1] = arr[insertIndex];
//数组变成了 34,101,119,1
//我们的34被保存到了insertValue中
insertIndex--;
}
//当退出while循环时，位置找到
arr[insertIndex+1] = insertValue;
System.out.println("第二次插入后的数组:"+ Arrays.toString(arr));
//第三轮
insertValue = arr[3];
insertIndex = 3-1;
while (insertIndex >=0 && insertValue <arr[insertIndex]){
//insertIndex >=0保证我们找位置的时候不越界
//insertValue <arr[insertIndex]==》说明我们还没找到位置
//没有找到位置，说明我们的insertIndex代表的值大，往后面走
arr[insertIndex+1] = arr[insertIndex];
//我们的34被保存到了insertValue中
insertIndex--;
}
//当退出while循环时，位置找到
arr[insertIndex+1] = insertValue;
System.out.println("第三次插入后的数组:"+ Arrays.toString(arr));
}
}
¿Por qué nuestro insertIndex necesita ser +1 cuando salimos? Porque restamos un 1 cuando definimos insertIndex al principio, que es similar a nuestro diagrama
En el diagrama, cada vez que insertamos un elemento, encontramos que hay una marca verde , esa es la posición de nuestro insertIndex , como 243, orden 3, ¿con quién debo comparar primero? Esta vez el subíndice 3 es 2 , él quiere hablar con el elemento comparativo 4 que está en el índice 1 , luego insertIndex es 2-1 , solo cuatro , se encontró relativamente poco, luego ingresamos el ciclo while, la matriz se convierte en 244, InsertIndex se convierte en 0 , y luego ir al ciclo de juicio. En este momento, insertValue> arr [insertIndex] , el insertIndex actual es la columna verde 2 , y nuestro 3 es más grande que el número verde, que era más pequeño que el anterior, por lo que insertó la posición En la posición de insertIndex + 1
Algoritmo de ordenación por inserción
/**
* @author 王庆华
* @version 1.0
* @date 2020/12/24 16:05
* @Description TODO
* @pojectname 插入排序算法
*/
public class InsertSort {
public static void main(String[] args) {
int[] arr = {
101,34,119,1};
insertSort(arr);
System.out.println(Arrays.toString(arr));
}
public static void insertSort(int[] arr){
for (int i = 1; i <arr.length; i++) {
//从1个元素开始，不需要减一，减一的话我们的最后一个元素就不插入了
int insertValue = arr[i];
int insertIndex = i-1;//跟谁比较，跟前面的数比较
//给insertValue找到插入位置
while (insertIndex >=0 && insertValue <arr[insertIndex]){
//insertIndex >=0保证我们找位置的时候不越界
//insertValue <arr[insertIndex]==》说明我们还没找到位置
//没有找到位置，说明我们的insertIndex代表的值大，往后面走
arr[insertIndex+1] = arr[insertIndex];
//数组变成了 101,101,119,1
//我们的34被保存到了insertValue中
insertIndex--;
}
arr[insertIndex+1] = insertValue;
}
}
}
El bucle for externo me controla para prepararme para insertar desde esa posición, la posición inicial es arr [1], porque arr [0] lo consideramos como una lista ordenada
Luego, el bucle exterior es arr [1], buscar ubicación arr [2] buscar ubicación ......
El bucle while interno se usa para encontrar la posición y determinar si es la posición que queremos insertar, que es lo que dijimos en el proceso de derivación.
Por supuesto, algunas personas preguntarán, si nuestro arr [insertIndex + 1] = insertValue ; los lugares son exactamente iguales, ¿no es necesario intercambiar? Puede agregar un si para juzgar, pero esta optimización tiene poco efecto
problema
Veamos los posibles problemas de ordenación por inserción simple:
Array arr = {2,3,4,5,6,1} En este momento, el número 1 (mínimo) que debe insertarse, el proceso es:
{2, 3,4, 5,6, 6}
{2,3,4,5,5, 6}
{2,3,4,4,5, 6}
{2,3,3,4,5, 6}
{ 2, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6}
Conclusión : cuando el número a insertar es un número pequeño, el número de turnos hacia atrás aumenta significativamente, lo que tiene un impacto sobre la eficiencia.
Entonces, ¿cómo optimizar el ordenamiento por inserción? =====> Orden de colina
Esta es la ordenación por inserción (ordenación por inserción directa). ¿Qué está mal o qué está mal? Hablemos de ello.