Programación Java: clasificación por algoritmo de inserción

introducción básica

La ordenación por inserción pertenece al método de ordenación interna, que consiste en encontrar la posición adecuada del elemento que se va a ordenar insertándolo para lograr el propósito de la ordenación.

Insertar idea de clasificación

La idea básica del ordenamiento por inserción (ordenamiento por inserción) es: tratar n elementos para ordenarlos como 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 se toma el primer elemento de la lista desordenada durante el proceso de clasificación, su código de clasificación se compara con el código de clasificación de los elementos de la lista ordenada a su vez, y se inserta en la posición adecuada en la lista ordenada para convertirlo Conviértete en una nueva lista ordenada.

Insertar diagrama de idea de ordenación

Insertar ejemplo de aplicación de ordenación

Hay un grupo de terneros, los puntajes de las pruebas son 101, 34, 119, 1 Por favor, ordene de pequeño a grande

Código

package sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class InsertSort {
    
    
    public static void main(String[] args) {
    
    
        //int[] arr = {101, 34, 119, 1, -1, 89, 27};
        //insertSort(arr);
        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++) {
    
    
            arr[i] = (int) (Math.random() * 80000);// 生成一个0-80000的数据
        }
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(date1);
        System.out.println("排序前的时间为：" + date1Str);
        insertSort(arr);
        Date date2 = new Date();
        String date2Str = simpleDateFormat.format(date2);
        System.out.println("排序后的时间为：" + date2Str);
        //System.out.println(Arrays.toString(arr));
    }

    public static void insertSort(int[] arr) {
    
    
        // 使用for循环
        int insertVal = 0;
        int insertIndex = 0;
        for (int i = 1; i < arr.length; i++) {
    
    
            insertVal = arr[i];
            insertIndex = i - 1;    // 及arr[1] 前面数字的下标
            // 给insertVal 找到插入的位置
            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
    
    
                // 说明
                // 1. insertIndex >= 0 保证给insertVal找插入位置不越界
                // 2. insertVal < arr[insertIndex] 说明待插入数字还没有找到适当位置
                // 3. 就需要将insertIndex后移
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            // 当退出while循环时，说明插入位置找到，insertIndex + 1
            // 判断是否需要赋值
            if (insertIndex + 1 != i) {
    
    
                arr[insertIndex + 1] = insertVal;
            }

        }

    }

    // 插入排序
    public static void insertSort1(int[] arr) {
    
    
        // 使用逐步推导的方法讲解
        // 第1轮 {101, 34, 119, 1} →→→ {34, 101, 119, 1}

        // 定义待插入的数字
        int insertVal = arr[1];
        int insertIndex = 1 - 1;    // 及arr[1] 前面数字的下标
        // 给insertVal 找到插入的位置
        while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
    
    
            // 说明
            // 1. insertIndex >= 0 保证给insertVal找插入位置不越界
            // 2. insertVal < arr[insertIndex] 说明待插入数字还没有找到适当位置
            // 3. 就需要将insertIndex后移
            arr[insertIndex + 1] = arr[insertIndex];
            insertIndex--;
        }
        // 当退出while循环时，说明插入位置找到，insertIndex + 1
        arr[insertIndex + 1] = insertVal;
        System.out.println("第1轮插入后：");
        System.out.println(Arrays.toString(arr));

        // 第2轮 {101, 34, 119, 1} →→→ {34, 101, 119, 1}

        // 定义待插入的数字
        insertVal = arr[2];
        insertIndex = 2 - 1;    // 及arr[1] 前面数字的下标
        // 给insertVal 找到插入的位置
        while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
    
    
            // 说明
            // 1. insertIndex >= 0 保证给insertVal找插入位置不越界
            // 2. insertVal < arr[insertIndex] 说明待插入数字还没有找到适当位置
            // 3. 就需要将insertIndex后移
            arr[insertIndex + 1] = arr[insertIndex];
            insertIndex--;
        }
        // 当退出while循环时，说明插入位置找到，insertIndex + 1
        arr[insertIndex + 1] = insertVal;
        System.out.println("第2轮插入后：");
        System.out.println(Arrays.toString(arr));

        // 第3轮 {101, 34, 119, 1} →→→ {1, 34, 101, 119}

        // 定义待插入的数字
        insertVal = arr[3];
        insertIndex = 3 - 1;    // 及arr[1] 前面数字的下标
        // 给insertVal 找到插入的位置
        while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
    
    
            // 说明
            // 1. insertIndex >= 0 保证给insertVal找插入位置不越界
            // 2. insertVal < arr[insertIndex] 说明待插入数字还没有找到适当位置
            // 3. 就需要将insertIndex后移
            arr[insertIndex + 1] = arr[insertIndex];
            insertIndex--;
        }
        // 当退出while循环时，说明插入位置找到，insertIndex + 1
        arr[insertIndex + 1] = insertVal;
        System.out.println("第3轮插入后：");
        System.out.println(Arrays.toString(arr));
    }
}

En conclusión

80.000 datos tardan entre 1 y 2 segundos, lo que es más rápido que el burbujeo.