java数据结构和算法——插入排序算法
目录
- 一、插入排序算法的基本介绍
- 二、插入排序算法的思想
- 三、插入排序算法的思路分析图
- 四、插入排序算法的应用示例需求
- 五、插入排序算法推导过程示例演示
- 六、插入排序算法的完整示例演示
- 七、测试插入排序算法所消耗的时间示例
一、插入排序算法的基本介绍
- 插入式排序属于内部排序法，是对于欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。
二、插入排序算法的思想
- 把n个待排序的元素看成为一个有序表和一个无序表
- 开始时有序表中只包含一个元素，无序表中包含有n-1个元素
- 排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。
三、插入排序算法的思路分析图
四、插入排序算法的应用示例需求
示例需求：有一群牛 , 颜值的打分分别是 101, 34, 119, 1 请使用插入排序从低到高进行排序
五、插入排序算法推导过程示例演示
1、代码
package com.rf.springboot01.dataStructure.sort;
import java.util.Arrays;
/**
* @description: 插入排序算法推导过程示例演示
* @author: xiaozhi
* @create: 2020-08-07 08:51
*/
public class InsertSort {
public static void main(String[] args) {
int[] arr={101, 34, 119, 1};
System.out.println("排序前的数组=================");
System.out.println(Arrays.toString(arr));
insertSort(arr);
System.out.println("排序后的数组=================");
System.out.println(Arrays.toString(arr));
}
public static void insertSort(int[] arr){
//第一轮排序的原数素组{101, 34, 119, 1}
int insertValue=arr[1];//定义一个待插入的数,第一次比较把34赋值给insertValue
int insertIndex= 1-1;//定义一个待插入的数前面的数的下标
//给insertValue 找到插入的位置
//1. insertIndex >= 0 保证在给insertValue 找插入位置，不越界
//2. insertValue < arr[insertIndex] 待插入的数，还没有找到插入位置
while(insertIndex>=0 && insertValue < arr[insertIndex]){
//将 arr[insertIndex] 后移,
//即第一次找位置是把arr[0]=101赋值给arr[1]的位置,示例中数组展示为101, 101, 119, 1
arr[insertIndex+1]=arr[insertIndex];
insertIndex--;
}
//当退出while循环时，说明插入的位置找到, insertIndex + 1
arr[insertIndex + 1] = insertValue;
System.out.println("第1轮插入排序后的数组-----------------");
System.out.println(Arrays.toString(arr));
//第二轮排序以第一轮排序的结果为基础{34, 101, 119, 1}
insertValue=arr[2];//定义一个待插入的数,第一次比较把119赋值给insertValue
insertIndex= 2-1;//定义一个待插入的数前面的数的下标
//给insertValue 找到插入的位置
//1. insertIndex >= 0 保证在给insertValue 找插入位置，不越界
//2. insertValue < arr[insertIndex] 待插入的数，还没有找到插入位置
while(insertIndex>=0 && insertValue < arr[insertIndex]){
//将 arr[insertIndex] 后移,
arr[insertIndex+1]=arr[insertIndex];
insertIndex--;
}
//当退出while循环时，说明插入的位置找到, insertIndex + 1
arr[insertIndex + 1] = insertValue;
System.out.println("第2轮插入排序后的数组-----------------");
System.out.println(Arrays.toString(arr));
//第三轮排序以第二轮排序的结果为基础{34, 101, 119, 1}
insertValue=arr[3];//定义一个待插入的数,第一次比较把1赋值给insertValue
insertIndex= 3-1;//定义一个待插入的数前面的数的下标
//给insertValue 找到插入的位置
//1. insertIndex >= 0 保证在给insertValue 找插入位置，不越界
//2. insertValue < arr[insertIndex] 待插入的数，还没有找到插入位置
while(insertIndex>=0 && insertValue < arr[insertIndex]){
//将 arr[insertIndex] 后移,
//第一次找位置是把arr[2]=119赋值给arr[3]的位置,示例中数组展示为34, 101, 119, 119
//第二次找位置是把arr[1]=101赋值给arr[2]的位置,示例中数组展示为34, 101, 101, 119
//第三次找位置是把arr[0]=34赋值给arr[1]的位置,示例中数组展示为34, 34, 101, 119
arr[insertIndex+1]=arr[insertIndex];
insertIndex--;
}
//当退出while循环时，说明插入的位置找到, insertIndex + 1
arr[insertIndex + 1] = insertValue;
System.out.println("第3轮插入排序后的数组-----------------");
System.out.println(Arrays.toString(arr));
}
}
2、运行main函数，运行结果如下：
六、插入排序算法的完整示例演示
1、代码
package com.rf.springboot01.dataStructure.sort;
import java.util.Arrays;
/**
* @description: 插入排序算法完整示例
* @author: xiaozhi
* @create: 2020-08-07 09:13
*/
public class InsertSort2 {
public static void main(String[] args) {
int[] arr={101, 34, 119, 1};
System.out.println("排序前的数组=================");
System.out.println(Arrays.toString(arr));
insertSort(arr);
System.out.println("排序后的数组=================");
System.out.println(Arrays.toString(arr));
}
public static void insertSort(int[] arr){
int insertValue=0;
int insertIndex=0;
for(int i=1;i<arr.length;i++){
//第一轮排序的原数素组{101, 34, 119, 1}
insertValue=arr[i];//定义一个待插入的数,第一次比较把34赋值给insertValue
insertIndex= i-1;//定义一个待插入的数前面的数的下标
//给insertValue 找到插入的位置
//1. insertIndex >= 0 保证在给insertValue 找插入位置，不越界
//2. insertValue < arr[insertIndex] 待插入的数，还没有找到插入位置
while(insertIndex>=0 && insertValue < arr[insertIndex]){
//将 arr[insertIndex] 后移,
//即第一次找位置是把arr[0]=101赋值给arr[1]的位置,示例中数组展示为101, 101, 119, 1
arr[insertIndex+1]=arr[insertIndex];
insertIndex--;
}
//当退出while循环时，说明插入的位置找到, insertIndex + 1
//这里我们判断是否需要赋值
if(insertIndex + 1 != i) {
arr[insertIndex + 1] = insertValue;
}
System.out.println("第"+i+"轮插入排序后的数组-----------------");
System.out.println(Arrays.toString(arr));
}
}
}
2、运行main函数，结果如下：
七、测试插入排序算法所消耗的时间示例
1、代码
package com.rf.springboot01.dataStructure.sort;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
/**
* @description: 插入排序耗时示例演示
* @author: xiaozhi
* @create: 2020-08-07 09:17
*/
public class InsertSort3 {
public static void main(String[] args) {
int arr[] = new int[100000];
for(int i=0;i<100000;i++){//创建一个带有100000个随机数的数组
arr[i]= (int) (Math.random()*8000000); //随机生成（0到8000000之间）的数
}
Date data1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1Str = simpleDateFormat.format(data1);
System.out.println("排序前的时间是=" + date1Str);
insertSort(arr);
Date data2 = new Date();
String date2Str = simpleDateFormat.format(data2);
System.out.println("排序前的时间是=" + date2Str);
}
public static void insertSort(int[] arr){
int insertValue=0;
int insertIndex=0;
for(int i=1;i<arr.length;i++){
//第一轮排序的原数素组{101, 34, 119, 1}
insertValue=arr[i];//定义一个待插入的数,第一次比较把34赋值给insertValue
insertIndex= i-1;//定义一个待插入的数前面的数的下标
//给insertValue 找到插入的位置
//1. insertIndex >= 0 保证在给insertValue 找插入位置，不越界
//2. insertValue < arr[insertIndex] 待插入的数，还没有找到插入位置
while(insertIndex>=0 && insertValue < arr[insertIndex]){
//将 arr[insertIndex] 后移,
//即第一次找位置是把arr[0]=101赋值给arr[1]的位置,示例中数组展示为101, 101, 119, 1
arr[insertIndex+1]=arr[insertIndex];
insertIndex--;
}
//当退出while循环时，说明插入的位置找到, insertIndex + 1
//这里我们判断是否需要赋值
if(insertIndex + 1 != i) {
arr[insertIndex + 1] = insertValue;
}
}
}
}
2、运行main函数，运行结果如下：
本地计算机，win10系统，8G内存测试带有100000个随机数的数组，用冒泡排序耗时大约1秒