插入排序(Insertion Sorting)的基本思想是:把N个待排序的元素看成为一个有序表和一个无序表,开始时有序表中只包含一个元素,无序表中包含有n-1个元素,排序过程中每次都从无序表中取出第一个元素,把它的排序码依次与有序表元素的排序码进行比较,将它插入到有序表中的适当位置。
二、案例原始数组:{100, 34, 80, 1}
需要对原始数组进行插入排序,每一轮都会确定一个最小数,且放到了最前面,所以轮数是n-1次。
第一轮插入排序:{34, 100, 80, 1}
核心思想:
1.可以想象为100这个数字(下标为0的)已经在左侧的有序表里了,所以需要从下标为1的数字开始拿
2.先从第二个数(下标为1的,这里是34)开始,让他和左边的数(也就是100)对比
3.值34小于100,所以将34放入到100的前面,所以第一轮是{34, 100, 80, 1}
第二轮插入排序:{34, 80, 100, 1}
核心思想:
1.再从第三个数(80)开始,让他和左边的数逐个对比
2.值80小于100,这时候不能直接放到左边后就不管了, 因为100左边还有数字,所以让80接着和100左边的数字34比较
3.值80大于34,所以不处理,所以最终位置是在100前面。也就是{34, 80, 100, 1}
第三轮插入排序:{1, 34, 80, 100}
三、coding核心思想:
1.从第四个数字(1)开始,让他和左边的数逐个对比
2.值1小于100, 因为100左边还有数字,所以让1接着和100左边的数字80比较
3.值1小于80, 因为80左边还有数字,所以让1接着和80左边的数字34比较
4.值1小于34,所以1放在34的左边,也就是最前面,{1, 34, 80, 100}
1、lowb演示版
package com.chentongwei.struct.sort;
import java.util.Arrays;
/**
* Description:
*
* @author TongWei.Chen 2020-01-07 17:05:54
*/
public class InsertSort {
public static void main(String[] args) {
int[] arr = {100, 34, 80, 1};
insertSort(arr);
}
/**
* 逐步推导的方式
*
* @param arr:待排序的数组
*/
private static void insertSort(int[] arr) {
// 第一轮
// {100, 34, 80, 1} =》{34, 100, 80, 1};
// 定义待插入的数组
int insertValue = arr[1];
// 也就是arr[1]前面的数,因为要跟前面的数对比
int insertIndex = 1 - 1;
// 给insertValue找到插入的位置
/*
* 1.insertIndex >= 0 保证再给insertValue找插入位置的时候,不越界
* 2.insertValue < arr[insertIndex] 说明待插入的值还没找到合适的位置,即需要将insertIndex往前移动,要让insertValue和其他值接着对比
*/
while (insertIndex >= 0 && insertValue < arr[insertIndex]) {
// {100, 100, 80, 1};
arr[insertIndex + 1] = arr[insertIndex];
insertIndex --;
}
// 当退出while循环的时候代表插入的位置找到,位置是insertIndex+1的位置
// {34, 100, 80, 1};
arr[insertIndex + 1] = insertValue;
System.out.println("第一轮插入:" + Arrays.toString(arr));
// 第二轮
// {34, 100, 80, 1} =》{34, 80, 100, 1};
// 定义待插入的数组
int insertValue2 = arr[2];
// 也就是arr[1]前面的数,因为要跟前面的数对比
int insertIndex2 = 2 - 1;
while (insertIndex2 >= 0 && insertValue2 < arr[insertIndex2]) {
arr[insertIndex2 + 1] = arr[insertIndex2];
insertIndex2 --;
}
// 当退出while循环的时候代表插入的位置找到,位置是insertIndex+1的位置
arr[insertIndex2 + 1] = insertValue2;
System.out.println("第二轮插入:" + Arrays.toString(arr));
// 第三轮
// {34, 80, 100, 1} =》{1, 34, 80, 100}
int insertValue3 = arr[3];
int insertIndex3 = 3 - 1;
while (insertIndex3 >= 0 && insertValue3 < arr[insertIndex3]) {
arr[insertIndex3 + 1] = arr[insertIndex3];
insertIndex3 --;
}
arr[insertIndex3 + 1] = insertValue3;
System.out.println("第三轮插入:" + Arrays.toString(arr));
}
}
第一轮插入:[34, 100, 80, 1]
第二轮插入:[34, 80, 100, 1]
第三轮插入:[1, 34, 80, 100]
2、优化版
lowb版明显发现硬编码,大量重复代码。如果数组长度是10000呢?那就写死了。但是规律很明显能发现出来:每次变化的地方就是insertValue和insertIndex两个变量的值 ,变化的规则就是每次都往后+1,因为每次都能确定一个值且放到最前面。所以下一轮就从前面+1开始就好了。规律找到了,那就很简单了,直接套层循环完事。
package com.chentongwei.struct.sort;
import java.util.Arrays;
/**
* Description:
*
* @author TongWei.Chen 2020-01-07 17:05:54
*/
public class InsertSort {
public static void main(String[] args) {
int[] arr = {100, 34, 80, 1};
insertSortNew(arr);
}
private static void insertSortNew(int[] arr) {
// 定义待插入的数组
int insertValue;
// 也就是arr[1]前面的数,因为要跟前面的数对比
int insertIndex;
for (int i = 1; i < arr.length; i ++) {
// 定义待插入的数组
insertValue = arr[i];
// 也就是arr[1]前面的数,因为要跟前面的数对比
insertIndex = i - 1;
// 给insertValue找到插入的位置
/*
* 1.insertIndex >= 0 保证再给insertValue找插入位置的时候,不越界
* 2.insertValue < arr[insertIndex] 说明待插入的值还没找到合适的位置,即需要将insertIndex往后移动,要让insertValue和其他值接着对比
*/
while (insertIndex >= 0 && insertValue < arr[insertIndex]) {
arr[insertIndex + 1] = arr[insertIndex];
// 和之前的对比
insertIndex --;
}
// 当退出while循环的时候代表插入的位置找到,位置是insertIndex+1的位置,这个判断是优化的手段
if (insertIndex + 1 != i) {
arr[insertIndex + 1] = insertValue;
}
System.out.println("第" + i + "轮插入:" + Arrays.toString(arr));
}
}
}
四、性能测试第1轮插入:[34, 100, 80, 1]
第2轮插入:[34, 80, 100, 1]
第3轮插入:[1, 34, 80, 100]
测试10w条数据,插入排序需要花费时间。
package com.chentongwei.struct.sort;
import java.util.Arrays;
/**
* Description:
*
* @author TongWei.Chen 2020-01-07 17:05:54
*/
public class InsertSort {
public static void main(String[] args) {
// 测试选择排序的效率,假设给10w个数据测试
int[] arr = new int[100000];
for (int i = 0; i < arr.length; i ++) {
// 生成【0,8000000】之间的一个随机数
arr[i] = (int)(Math.random() * 8000000);
}
long startTime = System.currentTimeMillis();
insertSortNew(arr);
long endTime = System.currentTimeMillis();
System.out.println("插入排序10w个数据所需要的时间是:" + (endTime - startTime) / 1000);
}
private static void insertSortNew(int[] arr) {
// 定义待插入的数组
int insertValue;
// 也就是arr[1]前面的数,因为要跟前面的数对比
int insertIndex;
for (int i = 1; i < arr.length; i ++) {
// 定义待插入的数组
insertValue = arr[i];
// 也就是arr[1]前面的数,因为要跟前面的数对比
insertIndex = i - 1;
// 给insertValue找到插入的位置
/*
* 1.insertIndex >= 0 保证再给insertValue找插入位置的时候,不越界
* 2.insertValue < arr[insertIndex] 说明待插入的值还没找到合适的位置,即需要将insertIndex往后移动,要让insertValue和其他值接着对比
*/
while (insertIndex >= 0 && insertValue < arr[insertIndex]) {
arr[insertIndex + 1] = arr[insertIndex];
// 和之前的对比
insertIndex --;
}
// 当退出while循环的时候代表插入的位置找到,位置是insertIndex+1的位置
if (insertIndex + 1 != i) {
arr[insertIndex + 1] = insertValue;
}
}
}
}
插入排序10w个数据所需要的时间是:1
可以发现只需要1s,当然这和机器的配置有关,但是在我机器上测试的话插入>选择>冒泡的。我这测试20w条数据也仅需要4s而已。