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

来源：互联网发布：java中布尔编辑：程序博客网时间：2024/06/03 09:27

基本思想

假设待排序的记录存放在数组R[0..n-1]中。初始时，R[0]自成1个有序区，无序区为R[1..n-1]。从i=1起直至i=n-1为止，依次将R[i]插入当前的有序区R[0..i-1]中，生成含n个记录的有序区。

算法实现

直接插入排序算法，Java实现，代码如下所示：

01public abstract class Sorter {
02     public abstract void sort(int[] array);
03}
04 
05public 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实现，代码如下所示：

01class 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 
12class 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

排序过程

直接插入排序的执行过程，如下所示：

初始化无序区和有序区：数组第一个元素为有序区，其余的元素作为无序区。
遍历无序区，将无序区的每一个元素插入到有序区正确的位置上。具体执行过程为：
每次取出无序区的第一个元素，如果该元素tmp大于有序区最后一个元素，不做任何操作；
如果tmp小于有序区最后一个元素，说明需要插入到有序区最后一个元素前面的某个位置，从后往前扫描有序区，如果有序区元素大于tmp，将有序区元素后移（第一次后移：tmp小于有序区最大的元素，有序区最大的元素后移覆盖无序区第一个元素，而无序区第一个元素的已经拷贝到tmp中；第二次后移：tmp小于有序区从后向前第二个的元素，有序区从后向前第二个元素后移覆盖有序区最大元素的位置，而有序区最后一个元素已经拷贝到无序区第一个元素的位置上；以此类推），直到找到一个元素比tmp小的元素（如果没有找到，就插入到有序区首位置），有序区后移操作停止。
接着，将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的索引。

可见，直接插入排序是稳定的。

转载地址：http://shiyanjun.cn/archives/790.html

0 0