插入排序-----------java实现

一、复杂度

平均时间复杂度： O(n²)
最差时： O(n²)
是否稳定： 稳定
空间开销： O(1)
在大部分数据已经排好序时性能较好
也很适合小规模数组

 二、基本思想

将n个待排序元素看成一个有序表和一个无序表，开始有序表只有一个元素，每次排序从无需表中取第一个元素，将它的值依此和有序表元素的数据比较，插入到有序表的适当位置，形成新的有序表
 

详解：

初始数据：18,   5,    54,   2,   33,   12

第一次排序：5，  18，  54，   2， 33，12

第二次排序：2，5，  18，  54， 33，12

第三次排序：2，5，12  18，  54， 33

第四次排序：2，5，12  18，33，  54

第五次排序：2，5，12  18，33，54

 

三、代码实现

/**
 * @author MaoLin Wang
 * @date 2020/2/1814:35
 */
public class InsertSort{
      /**
     * 插入排序 
     * @param arr
     */
    public static <T extends Comparable<? super T>> void insertSort(T [] arr){
        int j;
        for (int i = 1; i < arr.length; i++) {
            T temp=arr[i];

            for ( j = i; j >0&&temp.compareTo(arr[j-1])<0 ; j--) {
                arr[j]=arr[j-1];
            }
            arr[j]=temp;
        }

    }
    /**
     * 插入排序 对arr的left到right位置排序
     * @param arr
     * @param <T>
     */
    public static <T extends Comparable<? super T>> void insertSort(T [] arr,int left,int right){
        int j;
        for (int i = left; i <= right; i++) {
            T temp=arr[i];

            for ( j = i; j >left&&temp.compareTo(arr[j-1])<0 ; j--) {
                arr[j]=arr[j-1];
            }
            arr[j]=temp;
        }
    }
    public static void main(String[] args) {
        Integer [] arr={2,44,1,2,6,4};
        insertSort(arr);
        for(Integer i:arr){
            System.out.println(i);
        }
    }
}

结果：

第1次排序结果：
[43, 213, 22, 11, 324, 11, 4]
第2次排序结果：
[22, 43, 213, 11, 324, 11, 4]
第3次排序结果：
[11, 22, 43, 213, 324, 11, 4]
第4次排序结果：
[11, 22, 43, 213, 324, 11, 4]
第5次排序结果：
[11, 11, 22, 43, 213, 324, 4]
第6次排序结果：
[4, 11, 11, 22, 43, 213, 324]

四、测试100000条数据耗时

package com.wml.sort;

import java.util.Arrays;

/**
 * @author ***
 * @date 2019/10/2816:55
 */
public class InsertSort {
    public static void main(String[] args) {

        int[] array =new int[100000];
        for (int i=0;i<100000;i++){
            array[i]=(int)(Math.random()*100000);
        }

        long begintime=System.currentTimeMillis();
        System.out.println("开始时间"+begintime);

        insertSort(array);
        long endtime=System.currentTimeMillis();
        System.out.println("结束时间"+endtime);
        System.out.println("用时："+(endtime-begintime)+"ms");

    }

    public static void insertSort(int[] arr){

        for (int i=1;i<arr.length;i++){
            //待插入数据
            int insertVal=arr[i];
            //待插入位置下标
            int insertIndex=i-1;

            /**
             * 如果待插入下标小于零，说明待插入数据最小，应放在第一个位置
             * 如果待插入值大于arr[inserIndex]，则停止循环，说明待插入值在有序表中是最大的，应插入到当前insertIndex后一个位置
             */
            while (insertIndex>=0 && insertVal<arr[insertIndex]){
                arr[insertIndex+1]=arr[insertIndex];
                insertIndex--;
            }
            arr[insertIndex+1]=insertVal;


        }
    }
}

结果：

开始时间1572254640158
结束时间1572254641586
用时：1428ms

相比上一篇的选择排序的5811ms总体又快了许多