插入排序

插入排序的核心思想可以用打扑克牌时的理牌来表示，当整理牌时，我们将新的牌插入到相应的位置。对于一列数字，对于其中的任意一个数字，在前面的一个已排序子序列当中，找到自己合适的位置，插入进去。

/*插入排序*/   C语言
void Insert_Sort(ElementTypeA[], int N)
{  for(P=1; P<N; P++){
      Tmp=A[P];   //模下一张牌
      for(i=P;i>0 && A[i-1] > Tmp; i--)
         A[i] = A[i-1];   //移出空位
      A[i] = Tmp;   //新牌落位
   }
}

/*插入排序算法*/   C++
template <class Record>
void ImprovedInsertSort(Record Array[], int n){
	//Array[]为待排序数组，n为数组长度
	Record TempRecord;      //临时变量
	for (int i = 1; i < n; i++)   //依次插入第i个记录
	{
		TempRecord = Array[i];
		//从i开始往前寻找记录i的正确位置
		int j = i - 1;
		//将那些大于等于记录i的记录后移
		while ((j >= 0) && (TempRecord < Array[j]))
		{
			Array[j + 1] = Array[j];
			j = j - 1;
		}
		//此后j后面就是记录i的正确位置，回填
		Array[i + 1] = TempRecord;
	}
}

算法分析：

• 稳定
• 空间代价：O(1)
• 时间代价：

         -  最佳情况：n-1次比较，2（n-1）次移动，O(n)

         - 最差情况：O(n^2)

              比较次数为：

              移动次数为：

          - 平均情况：O(n^2)

• 直接插入排序的两个性质：
• 性质一：在最好的情况下（序本身已是有序的）下时间代价为O(n)
• 性质二：对于短序列，直接插入排序比较有效
• Shell排序有效利用了直接插入排序的这两个性质

Shell排序的算法思想

• 先将序列转化为若干个小序列，在这些小序列内进行插入排序
• 逐渐增加小序列的规模，而减小序列个数，使得待排序序列逐渐处于有序的状态
• 最后对整个序列进行扫尾直接插入排序，从而完成排序

演示一下shell排序过程，先取一个增量序列（例如：5，3，1）将一串需要排列的数列先按照5组分，每组三个数字。对数组三个数进行排序。接下来按照3组分，每组5个数。对每组五个数进行排序。接下来是1，也就是进行直接插入排序。

shell排序的执行时间依赖于增量序列。好的增量序列的共同特征：

（1）最后一个增量必须为1

 （2）应该互素

图解一：

/*原始希尔排序  D_m=N/2,D_k=D_k+1/2*/
void Shell_sort(ElementType A[], int N)
{   for(D=N/2; D>0; D/=2)  {     //希尔增量序列
       for(P=D; P<D; P++)  {    //插入排序
          Tmp = A[P];
          for(i=P; i>=D && A[i-D]>Tmp; i-=D)
             A[i] = A[i-D];
          A[i] = Tmp;
       }
    }
}

图解二：

/*增量每次除以2递减*/
template <class Record>
void ShellSort(Record Array[], int n)
//Shell排序，Array[]为特定排序数组，n为数组长度
{
	int i, delta;
	//增量delta每次除以2递减
	for (delta = n / 2; delta > 0; delta /= 2)
		for (i = 0; i < delta; i++)
			//分别对delta个子序列进行插入排序
			//“&”传Array[i]的地址，数组总长度为n-i
			ModInsSort(&Array[i], delta);
	//如果增量序列不能保证最后一个delta间距为1
	//可以安排下面这个扫尾性质的插入排序
	//ModInsSort(Array,n,1);
}

/*针对增量而修改的插入排序算法*/
template <class Record>
void ModInsSort(Record Array[], int n, int delta){
	int i, j;
	//对子序列中第i个记录，寻找合适的插入位置
	for (i = delta; i < n; i++)
		//j以delta为步长向前寻找逆置对其尽享调整
		for (j = i; j >= delta; j -= delta){
			if (Array[j] < Array[j - delta])//逆置
				swap(Array, j, j - delta);  //交换
			else
				break;
		}
}

算法分析：

• 不稳定
• 空间代价：O(1)
• 时间代价：增量每次除以2递减，O(n^2)
• 选择使得时间代价接近O(n)