直接插入排序

参考：直接插入排序、插入排序

插入排序介绍

插入排序(Insertion Sort)的基本思想是：每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子文件中的适当位置，直到全部记录插入完成为止。

两种插入排序方法：直接插入排序和希尔排序。

直接插入排序介绍

直接插入排序(Straight Insertion Sort)的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表。开始时有序表中只包含1个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，将它插入到有序表中的适当位置，使之成为新的有序表，重复n-1次可完成排序过程。

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

直接插入排序插入说明

第i-1趟直接插入排序：
    　通常将一个记录R[i](i=2，3，…，n-1)插入到当前的有序区，使得插入后仍保证该区间里的记录是按关键字有序的操作称第i-1趟直接插入排序。
    　排序过程的某一中间时刻，R被划分成两个子区间R[1．．i-1]（已排好序的有序区）和R[i．．n]（当前未排序的部分，可称无序区）。
    　直接插入排序的基本操作是将当前无序区的第1个记录R[i]插人到有序区R[1．．i-1]中适当的位置上，使R[1．．i]变为新的有序区。因为这种方法每次使有序区增加1个记录，通常称增量法。

直接插入排序的时间复杂度和稳定性分析

直接插入排序时间复杂度

直接插入排序的时间复杂度是O(N2)。

假设被排序的数列中有N个数。遍历一趟的时间复杂度是O(N)，需要遍历多少次呢？N-1！因此，直接插入排序的时间复杂度是O(N2)。

直接插入排序稳定性

直接插入排序是稳定的算法，它满足稳定算法的定义。

算法稳定性 -- 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的！

直接插入排序的实现

1、直接插入排序：待排序的元素存储在数组下标为l到r之间

/*
插入排序：i下标元素前面是已经排过序的
*/
void insertSort(Item a[], int l, int r)
{
	int i, j;
	for (i = l+1; i <= r; i++)
	{
		for(j = i; j > l; j--)
			compexch(a[j-1], a[j]);
	}
}

ps：考虑内层循环产生的多余操作

2、直接插入排序完整实现代码

#include <stdio.h>
#include <stdlib.h>

typedef int Item;
#define key(A) (A)
#define less(A, B) (key(A)<key(B))
#define exch(A, B) {Item t = A; A = B; B = t;}
#define compexch(A, B) if(less(B, A)) exch(A, B)	//最后A<B
/*
插入排序：i下标元素前面是已经排过序的
*/
void insertSort(Item a[], int l, int r)
{
	int i, j;
	for (i = l+1; i <= r; i++)
	{
		for(j = i; j > l; j--)
			compexch(a[j-1], a[j]);
	}
}

int main(void)
{
	int i, N, sw;	
	N = 50;
	sw = 1;
	int *a = (int *)malloc(N*sizeof(int));	//为数据a分配相应的存储空间
	if (sw)
	{
		for(i=0; i<N; i++)
		{
			a[i] = 1000 * (1.0 * rand()/RAND_MAX);
		}
	}
	else
	{
		for (i = 0; i < N; i++)
		{
			scanf("%d", &a[i]);
		}
	}
	puts("排序前");
	for(i=0; i<N; i++)
	{
		printf("%d ", a[i]);
	}
	sort(a, 0, N-1);
	puts("\n排序后");
	for(i=0; i<N; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
	return 0;
}

直接插入排序的分析与改进

一种查找比较操作和记录移动操作交替地进行的方法。
具体做法：
    　将待插入记录R[i]的关键字从右向左依次与有序区中记录R[j](j=i-1，i-2，…，1)的关键字进行比较：
    　① 若R[j]的关键字大于R[i]的关键字，则将R[j]后移一个位置；
       ②若R[j]的关键字小于或等于R[i]的关键字，则查找过程结束，j+1即为R[i]的插入位置。
    　关键字比R[i]的关键字大的记录均已后移，所以j+1的位置已经腾空，只要将R[i]直接插入此位置即可完成一趟直接插入排序。

一种引入哨兵的方法。

算法中引进的附加记录R[0]称监视哨或哨兵(Sentinel)。
   　 哨兵有两个作用：
　　① 进人查找(插入位置)循环之前，它保存了R[i]的副本，使不致于因记录后移而丢失R[i]的内容；
　　② 它的主要作用是：在查找循环中"监视"下标变量j是否越界。一旦越界(即j=0)，因为R[0].key和自己比较，循环判定条件不成立使得查找循环结束，从而避免了在该循环内的每一次均要检测j是否越界(即省略了循环判定条件"j>=1")。
  注意：
　  ① 实际上，一切为简化边界条件而引入的附加结点(元素)均可称为哨兵。
　　  【例】单链表中的头结点实际上是一个哨兵
　  ② 引入哨兵后使得测试查找循环条件的时间大约减少了一半，所以对于记录数较大的文件节约的时间就相当可观。对于类似于排序这样使用频率非常高的算法，要尽可能地减少其运行时间。所以不能把上述算法中的哨兵视为雕虫小技，而应该深刻理解并掌握这种技巧。

改进方法的实现

改进方法一：

void insertSort_1(Item a[], int l, int r)
{
	int i, j;
	Item v;
	for(i=l+1; i<=r; i++)
	{
		v = a[i];
		for(j=i-1; j>=l; j--)
		{
			if(a[j] > v)		//比待插入值大的元素向后移动
				a[j+1] = a[j];
			else
				break;			//跳出循环时候a[j]<=v,a[j+1]是v的最终插入位置
		}
		a[j+1] = v;
	}
}

改进方法二：

void insertSort_2(Item a[], int l, int r)
{
	int i;
	for(i=r; i>l; i--) compexch(a[i-1], a[i]);		//将最小的元素放到第一个位置，设置哨兵，是while循环的终止条件
	for(i=l+2; i<=r; i++)
	{
		int j=i;
		Item v=a[i];	//v为待插入的元素
		while(less(v, a[j-1]))		
		{
			a[j] = a[j-1];
			j--;
		}
		a[j]=v;
	}
}