[033]八大排序算法詳解——插入排序

基本思想

假設待排序的記錄存放在數組R[0..n-1]中。初始時，R[0]自成1個有序區，無序區爲R[1..n-1]。 從i=1起直至i=n-1爲止，依次將R[i]插入當前的有序區R[0..i-1]中，生成含n個記錄的有序區。

算法實現

直接插入排序算法，Java實現，代碼如下所示：

01	public abstract class Sorter {

02	public abstract void sort(int[] array);

03

}

04

05	public class StraightInsertionSorter extends Sorter {

06

07

@Override

08	public void sort(int[] array) {

09

int tmp;

10	for (int i = 1; i < array.length; i++) {

11	tmp = array[i]; // array[i]的拷貝

12	// 如果右側無序區第一個元素array[i] < 左側有序區最大的array[i-1]，

13	// 需要將有序區比array[i]大的元素向後移動。

14	if (array[i] < array[i - 1]) {

15	int j = i - 1;

16	while (j >= 0 && tmp < array[j]) { // 從右到左掃描有序區

17	array[j + 1] = array[j]; // 將左側有序區中元素比array[i]大的array[j+1]後移

18

j--;

19

}

20	// 如果array[i]>=左側有序區最大的array[i-1]，或者經過掃描移動後，找到一個比array[i]小的元素

21	// 將右側無序區第一個元素tmp = array[i]放到正確的位置上

22	array[j + 1] = tmp;

23

}

24

}

25

}

26

}

直接插入排序算法，Python實現，代碼如下所示：

01	class Sorter:

02

'''

03	Abstract sorter class, which provides shared methods being used by

04	subclasses.

05

'''

06	__metaclass__ = ABCMeta

07

08	@abstractmethod

09	def sort(self, array):

10

pass

11

12	class StraightInsertionSorter(Sorter):

13

'''

14	Straight insertion sorter

15

'''

16	def sort(self, array):

17

i = 0

18	length = len(array)

19	while i<length -1:

20

k = i

21

j = i

22	while j<length:

23	if array[j]<array[k]:

24

k = j

25

j = j + 1

26

if k!=i:

27	array[k], array[i] = array[i], array[k]

28

i = i + 1

排序過程

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

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，則執行排序過程如下所示：

1. 初始有序區爲{94}，無序區爲{12,34,76,26,9,0,37,55,76,37,5,68,83,90,37,12,65,76,49}。
2. 對於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}。
3. 對於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}。
4. 對於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}。

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

算法分析

• 時間複雜度

1. 最好情況：有序

   通過直接插入排序的執行過程可以看到，如果待排序數組恰好爲有序，則每次從大小爲n-1的無序區數組取出一個元素，和有序區最後一個元素比較，一定是比最後一個元素大，需要插入到有序區最後一個元素的後面，也就是原地插入。
   可見，比較次數爲n-1次，數組元素移動次數爲0次。

2. 最壞情況：逆序

   每次從無序區取出第一個元素，首先需要與有序區最後一個元素比較一次，然後繼續從有序區的最後一個元素比較，直到比較到有序區第一個元素，然後插入到有序區首位置。
   每次從無序區取出第一個元素，移動放到拷貝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的索引。

可見，直接插入排序是穩定的。

轉載地址：http://shiyanjun.cn/archives/790.html