基本思想

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

算法实现

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

public abstract class Sorter {
     public abstract void sort(int[] array);
}

public class StraightInsertionSorter extends Sorter {

     @Override
     public void sort(int[] array) {
          int tmp;
          for (int i = 1; i < array.length; i++) {
               tmp = array[i]; // array[i]的拷贝
               // 如果右侧无序区第一个元素array[i] < 左侧有序区最大的array[i-1]，
               // 需要将有序区比array[i]大的元素向后移动。
               if (array[i] < array[i - 1]) {
                    int j = i - 1;
                    while (j >= 0 && tmp < array[j]) { // 从右到左扫描有序区
                         array[j + 1] = array[j]; // 将左侧有序区中元素比array[i]大的array[j+1]后移
                         j--;
                    }
                    // 如果array[i]>=左侧有序区最大的array[i-1]，或者经过扫描移动后，找到一个比array[i]小的元素
                    // 将右侧无序区第一个元素tmp = array[i]放到正确的位置上
                    array[j + 1] = tmp;
               }
          }
     }
}

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

class Sorter:
    '''
    Abstract sorter class, which provides shared methods being used by
    subclasses.
    '''
    __metaclass__ = ABCMeta

    @abstractmethod
    def sort(self, array):
        pass

class StraightInsertionSorter(Sorter):
    '''
    Straight insertion sorter
    '''
    def sort(self, array):
        i = 0
        length = len(array)
        while i<length -1:
            k = i
            j = i
            while j<length:
                if array[j]<array[k]:
                    k = j
                j = j + 1
            if k!=i:
                array[k], array[i] = array[i], array[k]
            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的索引。
可见，直接插入排序是稳定的。