直接插入排序

直接插入排序（Straight Insertion Sort） 
基本思想：
先把要排序的数组分成两部分，第一部分只包含第一个元素，天然有序，而第二部分则包含了数组中除开第一个元素剩余的所有元素。然后依次将第二部分中的每一个元素插入到已经有序的第一部分中，并且仍保持第一部分有序。每次插入一个元素，有序部分将增加一个元素。
重复此过程，直到最后有序部分包含所有元素。

当然，有序部分也可以是最后一个元素。

好了，话不多说，上图。

初始数组如下：



第一步：进行划分。第一个元素 4 为初始有序部分，其余元素为无序部分。即红线左边为有序部分，右边为无序部分。



第二步：从无序部分的元素中依次找出一个元素插入到左边，并且保持插入后仍然有序。这里先将元素 2 插入到左边的有序部分。


<第一次插入>        2
< 4，因此将 2 插入到 4 的左边

此时，有序部分变成了 2、4， 接着，

第三步：将元素 3 插入到左边，并且保持插入后仍然有序。


<第二次插入>        3
< 4，3 > 2，因此将 3 插入到 2 和 4 的中间

此时，有序部分变成了 2、3、4， 继续，

第四步：将元素 5 插入到左边，并且保持插入后仍然有序。


<第三次插入>        5
> 4，将 5 直接插入到 4 的右边

此时，左边的有序部分变成了 2、3、4、5， 接着

第五步：将元素 1 插入到左边，并且保持插入后仍然有序。


<第四次插入>        1
< 5， 1 < 3， 1 < 2， 因此将 1 插入到 2 的左边

此时，所有元素都已经插入到了左边的有序部分，数组已经有序，排序结束。

其实，我们也看到了，插入排序的核心在于将无序部分元素插入到有序部分中，并且还得保持仍然有序。

就上边的情况来说，设定的是第一个元素为初始有序部分，余下元素为无序部分。其实，前面提到过，最后一个元素为初始有序部分也是可以的。完整的测试代码中包含了这种情况。

算法实现：    

/**
* 插入排序，最前一位作为有序部分
* @param arr 待排序数组
*/
public void insertionSort(int[] arr) {
int length = arr.length;
int j = 0;
int temp = 0;

for (int i = 1; i < length; i++) {
temp = arr[i]; // 存储待插入元素的值
for (j = i; j > 0; j--) { // 找到一个合适的插入位置
if (arr[j - 1] > temp)
arr[j] = arr[j - 1]; // 依次向右移动已经排好序的元素，为待插入元素留出位置
else // 若后面的不小于前面的，则不用移动，因为前面的已经排好序了
break;
}
arr[j] = temp; // 将待插入元素插入到指定位置
}
}

算法测试：

package algorithms;

import java.util.Arrays;
import java.util.Random;

/**
* 插入排序
* @author Wll
*
*/
public class InsertionSortTest {
public static void main(String[] args) {
int[] arr = getRandomArray(9, 1000);
int[] arr2 = Arrays.copyOf(arr, arr.length);
System.out.println("插入排序");
System.out.print("初始数组：");
printArray(arr);

System.out.println("第一位 " + arr[0] + " 为初始有序部分：");
insertionSort(arr);

System.out.println();

System.out.println("最后一位 " + arr2[arr2.length - 1] + " 为初始有序部分：");
insertionSort2(arr2);
}

/**
* 插入排序，最前一位作为有序部分
* @param arr 待排序数组
*/
private static void insertionSort(int[] arr) {
int length = arr.length;
int j = 0;
int temp = 0;

for (int i = 1; i < length; i++) {
temp = arr[i]; // 存储待插入元素的值
for (j = i; j > 0; j--) { // 找到一个合适的插入位置
if (arr[j - 1] > temp)
arr[j] = arr[j - 1]; // 依次向右移动已经排好序的元素，为待插入元素留出位置
else // 若后面的不小于前面的，则不用移动，因为前面的已经排好序了
break;
}
arr[j] = temp; // 将待排序元素插入到指定位置

// 打印每一趟排序的结果
System.out.print("第" + i + "趟插入" + temp + "： ");
for (int k = 0; k < length; k++) {
if (k == (i + 1))
System.out.print("|"); // 使用|分隔有序和无序部分

if (k == j)
System.out.print("▲"); // 为插入元素做标记

System.out.print(arr[k] + "  ");
}
System.out.println("\n");
}
}

/**
* 插入排序，最后一位作为有序部分
* @param arr 待排序数组
*/
private static void insertionSort2(int[] arr) {
int length = arr.length;
int j = 0;
int temp = 0;

for (int i = length - 2; i >= 0; i--) {
temp = arr[i];
for (j = i; j < length - 1; j++) {
if (arr[j + 1] < temp)
arr[j] = arr[j + 1];
else
break;
}
arr[j] = temp;

// 打印每一趟排序的结果
System.out.print("第" + (length - i - 1) + "趟插入" + temp + "： ");
for (int k = 0; k < length; k++) {
if (k == j)
System.out.print("▲"); // 为插入元素做标记

System.out.print(arr[k] + "  ");

if (k == i-1)
System.out.print("|"); // 使用|分隔有序和无序部分
}
System.out.println("\n");
}
}

/**
* 打印数组
* @param arr 待打印数组
*/
private static void printArray(int[] arr) {
int length = arr.length;
for (int i = 0; i < length; i++)
System.out.print(arr[i] + " ");
System.out.println();
System.out.println();
}

/**
* 获得一个随机整型数组
* @param size 数组大小
* @param limit 数组元素大小的上限
* @return 一个随机数组
*/
private static int[] getRandomArray(int size, int limit) {
int[] arr = new int[size];
Random random = new Random();
for (int i = 0; i < size; i++)
arr[i] = random.nextInt(limit);

return arr;
}
}

运行情况：