寫在前面：
簡單插入排序法其實比較好理解，他的算法過程類似於打撲克抓牌的過程。在我們抓到第一張牌之後，以後抓的每一張牌都會與之前手中的牌對比，對比之後，插入到合適的位置上，直到抓完最後一張牌。那麼在算法實現中，也是同理，我們假設數組索引爲0的元素有序，從數組索引爲1的元素開始，將arr[1]與arr[0]對比，如果大於arr[1]>arr[0],則插入到arr[0]的後面，如果arr[1]<arr[0],則插入到arr[0]的前面，依次類推。
例如：數組int [] arr = new int [] {2,5,3,1,6,8,4,7}，第一個元素爲2，默認就是有序的
- 第一次插入：插入元素5，比較後，插入到2的後面 -----[2，5] , 3, 1，6，8，4，7
- 第二次插入：插入元素3，比較後，插入到2的後面，5的前面-----[2，3 , 5] , 1，6，8，4， 7
- 第三次插入：插入元素1， 比較後，插入到2的前面 -----[1，2，3，5] ，6，8，4，7
- 第四次插入：插入元素6，比較後，插入到5的後面 -----[1，2，3，5，6] ，8，4，7
- 第五次插入：插入元素8，比較後，插入到6的後面 -----[1，2，3，5，6，8] ，4，7
- 第六次插入：插入元素4，比較後，插入到3的後面，5的前面-----[1，2，3，4，5，6，8] ，7
- 第七次插入：插入元素7，比較後，插入到6的後面，8的前面-----[1，2，3，4，5，6，7，8]
無論順序如何，都會經歷8-1次，這樣經過了n-1次插入，就完成了簡單插入排序。
代碼實現：
package test2;
/**
* 簡單插入排序
*
* @ClassName Test2
* @Description
* @author McGRADY
* @date 2018年3月8日
*/
public class Test2 {
public static void main(String[] args) {
int[] arr = new int[] { 7, 4, 2, 1, 5, 6, 3, 8 };
sort(arr);
for (int i : arr) {
System.out.print(i + ",");
}
}
public static void sort(int[] arr) {
int temp;
// 總計插入n-1次
for (int i = 1; i < arr.length; i++) {
temp = arr[i];
int j;
for (j = i - 1; j >= 0; j--) {
if (arr[j] > temp) {
arr[j + 1] = arr[j];
} else {
break;
}
}
arr[j + 1] = temp;
}
}
}時間複雜度分析：
通過上面的實例分析，我們可以看出，無論數組的順序如何，最後都要執行插入，也就是賦值語句arr[j+1]=temp，所以執行了n-1次。
而數組的移動次數則與數組的初始順序有關。當數組正序的時候，數字移動次數爲0.而當數組逆序的時候，交換次數(n-1)+(n-2)+......+1次，也就是=n*(n-1)/2次。
那麼，最好情況下：程序會執行（n-1）+0 次,時間複雜度爲O(n).
那麼，最壞情況下：程序會執行（n-1）+n*(n-1)/2次,時間複雜度爲O(n^2).
空間複雜度分析：
通過上面的實例分析，我們可以看出，簡單插入排序只是定義了一個變量temp，空間複雜度爲常量，即O(1)