五類插入排序

插入排序可分爲五類：

1．  直接插入排序算法

基本操作：將一個記錄插入到已排好序的有序表中，從而得到一個新的、記錄增1的有序表。

時間複雜度：O(n^2)

代碼：java表示

 

/** * 直接插入排序，升序排列。 * * @param data */ public void dirInsertSor(int[] data) { for (int i = 1; i < data.length; i++) { if (data[i] < data[i - 1]) { int temp = data[i]; int j; for (j = i - 1; j >= 0 && temp < data[j]; j--) { data[j + 1] = data[j]; } data[j + 1] = temp; } } }

 

分析：

    直接插入排序的好處就是算簡單明瞭,程序容易實現.但是效率就不可避免的比較低下.程序除了需要一個記錄數據的數組以外還要有一個臨時的輔助空間.

    從程序中可以看出,即使假設數組已經是順序的,程序仍舊需要進行n - 1次的比較,但是不用進行數組元素的移動.當數組是逆序的時候,程序需要進行(n + 2)(n - 1) / 2次的比較,另加(n + 4)(n - 1) / 2次的數組元素移動.綜上平均計算一下的話,差不多要進行(n ^ 2) / 4次的比較和移動,所以複雜度應該是O(n ^ 2).

 

2．  折半插入排序算法
基本操作：由於直接插入排序的基本操作是在一個有序表中進行查找的和插入的，所以這個“查找”操作可以利用“折半查找”來實現，這樣可以減少查找的時間複雜度。
時間複雜度：O(n^2)
代碼：java表示

 

/** * 折半插入排序，升序排列。 * * @param data */ public void halfInsertSor(int[] data) { for (int i = 1; i < data.length; i++) { if (data[i] < data[i - 1]) { int temp = data[i]; int index = halfSearch(data, 0, i - 1, temp); // 折半查找 for (int j = i; j > index; j--) { data[j] = data[j - 1]; } data[index] = temp; } } } /** * 折半查找的數組。如果數組data中沒有value，則返回比value大的元素中最小的元素所在的位置。 * * @param data * @param low * @param high * @param value * 要查找的值 * @return */ public int halfSearch(int[] data, int low, int high, int value) { int index = 0; while (low <= high) { index = (low + high) / 2; if (value == data[index]) { break; } else if (value < data[index]) { high = index - 1; } else { low = index + 1; } } return index; }

 

分析：這個方法可以減少數據比較的次數,但是數據移動還是要一步一步的進行(仍舊需要移動大約i / 2個已排好序的元素),所以時間複雜度沒有什麼實質的改善.治標不治本的方法.

3．  2-路插入排序算法

上面的二分插入減少的是數據比較的次數,而二路插入的方法可以減少數據移動的次數.

 

/** * 2-路插入排序，升序排列。 * * @param data */ public void twoWayInsertSort(int[] data) { int low, high, keyIndex, index; int length = data.length; int[] b = new int[length]; // 輔助記錄空間 low = high = 0; b[0] = data[0]; for (int i = 1; i < length; i++) { if (data[i] <= b[low]) { // 當數據小於或等於最小值時 low = (low - 1 + length) % length; b[low] = data[i]; } else if (data[i] > b[high]) { // 當數據大於最大值時 high = (high + 1 + length) % length; b[high] = data[i]; } else { // 當數據在最大值和最小值之間時 keyIndex = (high - 1 + length) % length; while (true) { if (b[keyIndex] <= data[i]) { index = high; high = (high + 1 + length) % length; while (index != keyIndex) { b[(index + 1 + length) % length] = b[index]; index = (index - 1 + length) % length; } b[(keyIndex + 1 + length) % length] = data[i]; break; } keyIndex = (keyIndex - 1 + length) % length; } } } for (int i = 0; i < length; i++) { data[i] = b[(low + i) % length]; } }

 

 

這個二路插入的算法可以比二分插入算法節約一半的運行時間,但是程序比較複雜.
    上面的程序另外使用了一個大小爲n的輔助空間,並且把b看成了循環向量.low是數組中最小的元素,high是數組中最大的元素,如果待排序的元素小於low則放在first的前面,如果比high小則放在high的後面.

    在<<計算機程序設計藝術>>中作者說到過一種方法,把輸入區域當作一個循環表,而且位置N同1相鄰.根據上一次插入的元素是落在已排序元素的中心的左面還是右面,而從當前未排序元素段的右面或是左面來取新的元素.過後通常需要"轉動"這個區域.通過這個方法可以僅用N + 1的空間同時進行輸入,輸出和排序.

4．  表插入排序算法
基本操作：和直接插入排序相比，不同之處僅是以修改2n次指針代替了移動記錄，排序過程中所需進行的關鍵字間比較次數相同。
時間複雜度：O(n^2)
代碼：略
5．  希爾排序（縮小增量排序）算法
      基本思想：
　　不斷把待排序的對象分成若干個小組，對同一小組內的對象採用直接插入法排序，當完成了所有對象都分在一個組內的排序後，排序過程結束。每次比較指定間距的兩個數據項，若左邊的值小於右邊的值，則交換它們的位置。間距d按給定公式減少： di+1 =（di +1）/2 ，直到d等於1爲止。D可以選取{9，5，3，2，1}。
算法步驟：
　　Step1 將n個元素個數列分爲5個小組，在每個小組內按直接插入法排序；
　　step2 在第i步，分組個數取 di+1 =（di +1）/2 {9，5，3，2，1}；相臨兩組之間的對應元素進行比較，如果ai>aj，則交換它們的位置；
　　Step3 當dK = 1的循環過程完成後，排序過程結束。
基本操作：先將整個待排記錄序列分割成爲若干子序列分別進行直接插入排序，待整個序列中的記錄“基本有序”時，再對全體記錄進行一次直接插入排序。
希爾排序的一個特點是：子序列的構成不是簡單地“逐段分割”，而是將相隔某個“增量” 的記錄組成一個子序列。希爾排序的分析是一個複雜的問題，因爲它的時間是所取“增量”序列的函數，這涉及一些數學上尚未解決的難題。因此，到目前爲止尚未有人求得最好的增量序列。增量序列可以有各種方法，但需要注意：應使增量序列中的值沒有除1之外的公因子；並且最後一個增量值必須等於1。
c 代碼：

void shellsort(int v[], int n) { int gap, i, j, temp; for(gap=n/2;gap>0;gap/=2) //設定步長 for(i=gap;i<n;++i) //在元素間移動爲止 for(j=i-gap; j>=0&&v[j]>v[j+gap]; j-=gap){ //比較相距gap的元素，逆序互換 temp=v[j]; v[j]=v[j+gap]; v[j+gap]=temp; } }

 

分析：Shell排序的時間複雜度不是O(n ^ 2),而是根據所選的增量序列而定的.

 

本文來自CSDN博客，轉載請標明出處：http://blog.csdn.net/lixiang040330624/archive/2009/10/09/4647512.aspx