数据结构——排序——插入排序——直接插入排序

排序的定义

排序：就是重新排列表中的元素，使表中的元素满足按关键字有序的过程

算法的稳定性：若待排序表中有两个元素 A 和 B，其对应的关键字 a = b，且在排序前 A 在 B 前面，若使用某一排序算法排序后，A 仍然在 B 的前面，则称这个排序算法是稳定的，否则称排序算法是不稳定的

直接插入排序

要将元素 L(i) 插入到已有序的子序列 L[1…i-1] 中，需要执行以下操作
1）查找出 L(i) 在 L[1…i-1] 中的插入位置 k
2）将 L[k…i-1] 中的所有元素依次往后移一个位置
3）将 L(i) 复制到 L(k)

i = 1    (49) 38 65 97 76 13 27 49
i = 2    (38 49) 65 97 76 13 27 49
i = 3    (38 49 65) 97 76 13 27 49
i = 4    (38 49 65 97) 76 13 27 49
i = 5    (38 49 65 76 97) 13 27 49
i = 6    (13 38 49 65 76 97) 27 49
i = 7    (13 27 38 49 65 76 97) 49
i = 8    (13 27 38 49 49 65 76 97)

空间复杂度：仅使用了常数个辅助单元，所有空间复杂度为 O(1)

时间复杂度：O($n^2$)

算法稳定性：由于每次插入元素时总是从后向前先比较再移动，所以不会出现相同元素相对位置发生变化的情况，即直接插入排序是一个稳定的排序方法

算法适用性：直接插入排序算法适用于顺序存储和链式存储的线性表。为链式存储时，可以从前往后查找指定元素的位置

普通模式

/**
 * 直接插入排序：普通模式
 */
void insertSort(int A[], int n) {
    int i, j, temp;
    for (i = 1; i < n; ++i) {
        if (A[i] < A[i - 1]) {
            temp = A[i];
            for (j = i - 1; j >= 0 && A[j] > temp; --j) {
                A[j + 1] = A[j];
            }
            A[j + 1] = temp;
        }
    }
}

int main(void) {
	int a[] = {10,4,6,8,5,2,3,1,7,9};
	insertSort(a,sizeof(a)/sizeof(int));
	for(int i = 0; i < sizeof(a)/sizeof(int); i++) {
		printf("%d ",a[i]);
	}
	return 0;
}

哨兵模式

/**
 * 直接插入排序：哨兵模式（A[0]作为哨兵）
 */
void insertSort(int A[], int n) {
	int i, j;
	for(i = 2; i <= n; i++) {                 //依次将A[2]~A[n]插入到前面已排序序列
		if(A[i] < A[i-1]) {                   //若A[i]关键码小于其前驱，将A[i]插入有序表
			A[0] = A[i];                      //复制为哨兵，A[0]不存放元素
			for(j = i-1; A[0] < A[j]; j--) {  //从后往前查找待插入位置
				A[j+1] = A[j];                //向后挪位
			}
			A[j+1] = A[0];                    //复制到插入位置
		}
	}
}

int main(void) {
	int a[] = {0,4,6,8,5,2,3,1,7,9};
	insertSort(a,sizeof(a)/sizeof(int));
	for(int i = 1; i < sizeof(a)/sizeof(int); i++) {
		printf("%d ",a[i]);
	}
	return 0;
}