一、直接插入排序（Straight Insertion Sort）

基本思想

n個記錄的文件的直接選擇排序可通過n-1趟直接選擇排序獲得有序結果：

1. 初始狀態：無序區爲R[1..n]，有序區爲空。
2. 第1趟排序：在無序區R[1..n]中選出關鍵字最小的記錄R[k]，將它與無序區的第1個記錄R[1] 交換，使R[1..1]和R[2..n]分別變爲記錄個數增長1個的新有序區和記錄個數減小1個的新無序區。
3. ……
4. 第i趟排序：第i趟排序開始時，當前有序區和無序區分別爲R[1..i-1]和R[i..n](1≤i≤n-1)。 該趟排序從當前無序區中選出關鍵字最小的記錄R[k]，將它與無序區的第1個記錄R[i]交換，使R[1..i] 和R[i+1..n]分別變爲記錄個數增長1個的新有序區和記錄個數減小1個的新無序區。

這樣，n個記錄的文件的直接選擇排序可通過n-1趟直接選擇排序獲得有序結果。

---

//Java 代碼

public class StraightInsertionSorter{
   
    public void sort(int[] arr) {
       int tmp;
       for(int i=1;i<arr.length;i++){
           tmp=arr[i];// 暫存arr[i]
           // 若是右側無序區第一個元素arr[i] < 左側有序區最大的arr[i-1]，
	   // 須要將有序區比arr[i]大的元素向後移動。
           if(arr[i]<arr[i-1]){
              int j=i-1;
              while(j>=0 && tmp<arr[j]){// 從右到左掃描有序區
                   arr[j+1]=arr[j];// 將左側有序區中元素比arr[i]大的arr[j+1]後移
                   j--;
              }
              // 若是array[i]>=左側有序區最大的arr[i-1]，或者通過掃描移動後，找到一個比arr[i]小的元素
	      // 將右側無序區第一個元素tmp = arr[i]放到正確的位置上
              arr[j+1]=tmp;
           }
       }
    }
}

排序過程

直接插入排序的執行過程，以下所示：

1. 初始化無序區和有序區：數組第一個元素爲有序區，其他的元素做爲無序區。
2. 遍歷無序區，將無序區的每個元素插入到有序區正確的位置上。具體執行過程爲：
   每次取出無序區的第一個元素，若是該元素tmp大於有序區最後一個元素，不作任何操做；
   若是tmp小於有序區最後一個元素，說明須要插入到有序區最後一個元素前面的某個位置，從後往前掃描有序區，若是有序區元素大於tmp，將有序區元素後移 （第一次後移：tmp小於有序區最大的元素，有序區最大的元素後移覆蓋無序區第一個元素，而無序區第一個元素的已經拷貝到tmp中；第二次後移：tmp小 於有序區從後向前第二個的元素，有序區從後向前第二個元素後移覆蓋有序區最大元素的位置，而有序區最後一個元素已經拷貝到無序區第一個元素的位置上；以此 類推），直到找到一個元素比tmp小的元素（若是沒有找到，就插入到有序區首位置），有序區後移操做中止。
3. 接着，將tmp插入到：從有序區由前至後找到的第一個比tmp小的元素的後面便可。此時，有序區增長一個元素，無序區減小一個元素，直到無序區元素個數爲0，排序結束。

下面，經過實例來演示執行直接插入排序的過程，假設待排序數組爲array = {94,12,34,76,26,9,0,37,55,76,37,5,68,83,90,37,12,65,76,49}，數組大小爲20，則執行排序過程以下所示：

    初始有序區爲{94}，無序區爲{12,34,76,26,9,0,37,55,76,37,5,68,83,90,37,12,65,76,49}。
    對於array[1] = 12（無序區第一個元素）：臨時拷貝tmp = array[1] = 12，tmp = 12小於有序區{94}最後一個元素(94)，由於有序區只有一個元素，因此將tmp插入到有序區首位置，此時，有序區爲{12,94}，無序區爲{34,76,26,9,0,37,55,76,37,5,68,83,90,37,12,65,76,49}。
    對於array[2] = 34（無序區第一個元素）：臨時拷貝tmp = array[2] = 34，tmp = 34小於有序區{12,94}最後一個元素(94)，將94後移覆蓋array[2]，亦即：array[2] = 94；繼續將tmp = 34與有序區{12,94}從後向前第二個元素比較，tmp = 34 > 12，則直接將tmp = 34插入到12後面的位置。此時，有序區爲{12,34,94}，無序區爲{76,26,9,0,37,55,76,37,5,68,83,90,37,12,65,76,49}。
    對於array[3] = 76（無序區第一個元素）：臨時拷貝tmp = array[3] = 76，tmp = 76小於有序區{12,34,94}最後一個元素(94)，將94後移覆蓋array[3]，亦即：array[3] = 94；繼續將tmp = 76與有序區{12,34,94}從後向前第二個元素比較，tmp = 76 > 34，則直接將tmp = 76插入到34後面的位置。此時，有序區爲{12,34,76,94}，無序區爲{26,9,0,37,55,76,37,5,68,83,90,37,12,65,76,49}。

……
依此類推執行，直到無序區沒有元素爲止，則有序區即爲排序後的數組。

算法分析

    時間複雜度

    最好狀況：有序

    經過直接插入排序的執行過程能夠看到，若是待排序數組剛好爲有序，則每次從大小爲n-1的無序區數組取出一個元素，和有序區最後一個元素比較，必定是比最後一個元素大，須要插入到有序區最後一個元素的後面，也就是原地插入。
    可見，比較次數爲n-1次，數組元素移動次數爲0次。
    最壞狀況：逆序

    每次從無序區取出第一個元素，首先須要與有序區最後一個元素比較一次，而後繼續從有序區的最後一個元素比較，直到比較到有序區第一個元素，而後插入到有序區首位置。
    每次從無序區取出第一個元素，移動放到拷貝tmp中，而後再將tmp與有序區元素比較，這個比較過程一共移動的次數爲：有序區數組大小，最後還要將拷貝tmp移動插入到有序區的位置上。
    在這個過程當中：
    有序區數組大小爲1時，比較2次，移動3次；
    有序區數組大小爲2時，比較3次，移動4次；
    ……
    有序區數組大小爲n-1時，比較n次，移動n+1次。
    可見：
    比較的次數爲：2+3+……+n = (n+2)(n-1)/2
    移動的此時爲：3+4+……+n+1 = (n+4)(n-1)/2

經過上面兩種狀況的分析，直接插入排序的時間複雜度爲O(n2)。

    空間複雜度

在直接插入排序的過程當中，只用到一個tmp臨時存放待插入元素，所以空間複雜度爲O(1)。

    排序穩定性

經過上面的例子來看： 當有序區爲{0,9,12,26,34,37,55,76,94}，無序區爲{76,37,5,68,83,90,37,12,65,76,49}的時候，執行下一趟直接插入排序： 對於array[9] = 76（無序區第一個元素）： 臨時拷貝tmp = array[9] = 76，tmp = 76小於有序區{0,9,12,26,34,37,55,76,94}最後一個元素(94)，將94後移覆蓋array[9]，亦即：array[9] = 94；繼續將tmp = 76與有序區{0,9,12,26,34,37,55,76,94}從後向前第二個元素(76)比較，tmp = 76 = 76，則直接將tmp = 76插入到有序區數組元素76後面的位置。此時，有序區爲{0,9,12,26,34,37,55,76,76,94}，無序區爲{37,5,68,83,90,37,12,65,76,49}。 繼續執行直至完成的過程當中，對於兩個相等的數組元素，原始爲排序數組中索引位置的大小關係並無發生改變，也就是說，對於值相等的元素e，存在ei1，ei2，……eik，其中i1，i2……ik是數組元素e在爲排序數組中的索引位置，排序前有i1<i2<……<ik，排序後仍然有j1<j2<……<jk，其中j1<j2<……<jk爲排序後值相等的元素e的索引。 可見，直接插入排序是穩定的。