【Java中经典算法-插入排序】
插入排序（一）
1、基本思想
一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间
2、排序分析
3、效果图
代码实现如下：
/**
* ClassName:InsertSort2 <br/>
*
* Function: TODO ADD FUNCTION. <br/>
* Reason: TODO ADD REASON. <br/>
* Date: 2019年4月19日 下午12:14:14 <br/>
*
* @author Administrator
* @version
* @since JDK 1.8
* @see
*/
public class InsertSort2 {
public static void main(String[] args) {
int[] ins = { 3, 1, 6, 2, 5 };
int[] ins2 = sort(ins);
for (int in : ins2) {
System.out.println(in);
}
}
public static int[] sort(int[] ins) {
for (int i = 1; i < ins.length; i++) {
for (int j = i; j > 0; j--) {
if (ins[j] < ins[j - 1]) {
int temp = ins[j - 1];
ins[j - 1] = ins[j];
ins[j] = temp;
}
}
}
return ins;
}
}针对上面的这个排序算法改进：首先上面的这个每次替换都要定义一个temp赋值需要插入的数，这样会造成不必要的浪费：
所以我们可以把所有的大于需要插入的数先保存，然后进行比较，然后将最后的正确位置空出来。吧之前保存的需要插入的数放到正确位置上。
public static int[] sort2(int[] ins) {
for (int i = 1; i < ins.length; i++) {
int temp = ins[i];// 保存每次需要插入的那个数
int j;
for (j = i; j > 0 && ins[j - 1] > temp; j--) {// 这个较上面有一定的优化
ins[j] = ins[j - 1];// 把大于需要插入的数往后移动。最后不大于temp的数就空出来
}
ins[j] = temp;// 将需要插入的数放入这个位置
}
return ins;
}
插入排序（二）
1、基本实现
每次将一个待排序的数据元素，插入到前面已经排好序的数列中的适当位置，使数列依然有序；直到待排序数据元素全部插入完为止。
2、排序过程
[初始关键字] [49] 38 65 97 76 13 27 49
J=2(38) [38 49] 65 97 76 13 27 49
J=3(65) [38 49 65] 97 76 13 27 49
J=4(97) [38 49 65 97] 76 13 27 49
J=5(76) [38 49 65 76 97] 13 27 49
J=6(13) [13 38 49 65 76 97] 27 49
J=7(27) [13 27 38 49 65 76 97] 49
J=8(49) [13 27 38 49 49 65 76 97]
代码实现：
/**
* ClassName:InsertSort <br/>
*
* Function: 直接插入排序： 注意所有排序都是从小到大排 Date: 2019年4月19日 下午12:09:15 <br/>
*
* @author Administrator
* @version
* @since JDK 1.8
* @see
*/
public class InsertSort {
/**
* 排序算法的实现，对数组中指定的元素进行排序
*
* @param array 待排序的数组
* @param from 从哪里开始排序
* @param end 排到哪里
* @param c 比较器
*/
public void insert(Integer[] array, int from, int end) {
/*
* 第一层循环：对待插入（排序）的元素进行循环 从待排序数组断的第二个元素开始循环，到最后一个元素（包括）止
*/
for (int i = from + 1; i <= end; i++) {
/*
* 第二层循环：对有序数组进行循环，且从有序数组最第一个元素开始向后循环 找到第一个大于待插入的元素
* 有序数组初始元素只有一个，且为源数组的第一个元素，一个元素数组总是有序的
*/
for (int j = 0; j < i; j++) {
Integer insertedElem = array[i];// 待插入到有序数组的元素
// 从有序数组中最一个元素开始查找第一个大于待插入的元素
if ((array[j].compareTo(insertedElem)) > 0) {
// 找到插入点后，从插入点开始向后所有元素后移一位
move(array, j, i - 1);
// 将待排序元素插入到有序数组中
array[j] = insertedElem;
break;
}
}
}
// =======以下是java.util.Arrays的插入排序算法的实现
/*
* 该算法看起来比较简洁一j点，有点像冒泡算法。 将数组逻辑上分成前后两个集合，前面的集合是已经排序好序的元素，而后面集合为待排序的
* 集合，每次内层循从后面集合中拿出一个元素，通过冒泡的形式，从前面集合最后一个元素开 始往前比较，如果发现前面元素大于后面元素，则交换，否则循环退出
*
* 总感觉这种算术有点怪怪，既然是插入排序，应该是先找到插入点，而后再将待排序的元素插
* 入到的插入点上，那么其他元素就必然向后移，感觉算法与排序名称不匹，但返过来与上面实
* 现比，其实是一样的，只是上面先找插入点，待找到后一次性将大的元素向后移，而该算法却 是走一步看一步，一步一步将待排序元素往前移
*/
/*
* for (int i = from; i <= end; i++) { for (int j = i; j > from &&
* c.compare(array[j - 1], array[j]) > 0; j--) { swap(array, j, j - 1); } }
*/
}
/**
* 数组元素后移
*
* @param array 待移动的数组
* @param startIndex 从哪个开始移
* @param endIndex 到哪个元素止
*/
public void move(Integer[] array, int startIndex, int endIndex) {
for (int i = endIndex; i >= startIndex; i--) {
array[i + 1] = array[i];
}
}
public static void main(String[] args) {
Integer[] intgArr = { 3, 1, 6, 2, 5 };
InsertSort insertSort = new InsertSort();
insertSort.insert(intgArr, 0, intgArr.length - 1);
for (Integer intObj : intgArr) {
System.out.print(intObj + " ");
}
}
}