C语言-插入排序（Insertion Sort）

1.直接插入排序（Straight Insertion Sort）：

1. r[0]是哨兵，r[1]~r[i-1]是已经排好的有序序列，r[i]以后的是待排序的无序序列
2. 基本思想：每次将一个待排序的元素r[i]，按其关键字大小插入到前面已经排好序的子序列中的适当位置，直到全部元素插入完成为止。
3. 此算法的关键在于：① 寻找到插入位置 ② 搬动元素，挪出插入的空间

void InsertSort(int *r)
{
	int i,j;
	
	for(i=2;i<Maxsize;i++)//r[0]是哨兵，存放当前的插入元素 
	{/*当元素r[i]比 有序集合r[1]~r[i-1] 中最后一个元素(也是最大的元素) r[i-1]还小时（即r[i]<r[i-1]），满足插入条件，
	  否则跳过该元素，执行 i++，继续向后寻找合适的插入元素 */ 
		if(r[i]<r[i-1])
		{
			r[0]=r[i];//将当前插入元素r[i]放入哨兵r[0]
			r[i]=r[i-1];//将r[i-1]向后推一个位置,则r[i-1]的位置空出 
			for(j=i-2;r[0]<r[j];j--)//在有序集合中寻找插入位置 
			{
				r[j+1]=r[j]; //逐个向后搬动 
			} 
		    r[j+1]=r[0]; //插入查找到位置 
		}
		
	}
}

4. 总结：

• 时间复杂度分析：
  ① 最好情况：基本有序（正序），不需要进行大规模的查找和搬动
  ② 最坏情况：逆序，最小的元素在表尾，每处理一个元素都需要从表尾开始走到表头去查找插入位置，然后把所有表中元素都往后挪一位，给最小的元素腾出第一个空间
  ③总结：平均情况关键字的查找比较次数和元素搬动次数均为n²/4，故时间复杂度为O(n²)
• 空间复杂度：只需要r[0]一个临时存储空间，所以空间复杂度为O（1）

---

2.算法升级：折半插入排序（Binary Insertion Sort）：

1. 算法整体与直接插入排序基本一致，唯一改变了查找插入位置的方式，由顺序查找升级为折半查找，所以叫折半插入排序
2. 折半插入排序不适用于链表，因为要对坐标进行折半查找，故只能在顺序表中运行

void BinarySort(int *r)
{
	int i,j;
	int low,mid,high;
	
	for(i=2;i<Maxsize;i++)
	{
		r[0]=r[i];//哨兵
		
		low=1;
		high=i-1;
		
		while(low<=high)//用折半查找法查找插入位置 
		{
			mid=(low+high)/2;
			
			if(r[0]<r[mid])
			{
				high=mid-1;
			}
			
			else 
			    low=mid+1;
		} 
		
		for(j=i-1;j>high;j--)//将后半段往后搬一位 
		{
			r[j+1]=r[j];
		}
		r[high+1]=r[0];//插入 
	}
} 

直接插入与者半插入比较：

3. 总结：

• 时间复杂度分析：
  ① 因为算法本质上与直接插入排序一致，知识改变了查找插入位置的方式，由上图我们可以很明显的看出，折半插入排序有效的减少了比较次数，增加了查找插入位置的效率。
  ② 但是，元素的搬动次数没变，找到插入位置后，仍需要将插入位置之后的所有元素向后挪一个位置
  ③ 所以时间复杂度仍为O(n²)

• 空间复杂度：只需要r[0]一个临时存储空间，所以空间复杂度为O（1）

---

3.再升级：希尔排序（Shell’s Sort）

1. 希尔排序，又称"缩小增量排序"(Diminishing Increment Sort) ，原理是不断地缩小增量gap，同时不断的对当前增量gap(步长)的分组进行直接插入排序，直到gap=0
2. 简单地说，希尔排序就是分组插入排序。
3. 基本思想：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。
4. 因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。

void ShellSort(int *r)
{
	int i,k;
	int gap;//gap为步长(增量)，
	int temp;//临时存储变量temp，相当于直接插入排序中的r[0].
	//(注：因为希尔排序每次移动的步长gap不为 1，所以不能用r[0]作为哨兵！) 
	
	for(gap=Maxsize/2;gap>0;gap=gap/2) 
	{
		for(i=gap;i<Maxsize;i++)//直接插入排序 
		{
			if(r[i]<r[i-gap])
			{
				temp=r[i]; 
				
				for(k=i-gap;k>=0&&r[k]>temp;k=k-gap)//因为没有哨兵，所以要加上 k>=0 
				{
					r[k+gap]=r[k];//向后搬动 
				}
				r[k+gap]=temp;
			}
		}
	}
} 

• 执行结果：

原序列：49 38 65 97 26 13 27 49 55 4

gap=5   13 27 49 55 4 49 38 65 97 26

gap=2   4 26 13 27 38 49 49 55 97 65

gap=1   4 13 26 27 38 49 49 55 65 97

gap=0   4 13 26 27 38 49 49 55 65 97
--------------------------------
Process exited after 0.03134 seconds with return value 0
请按任意键继续. . .

3. 总结：

• 希尔排序快在何处？
  ① 分多组处理，当增量gap>1时，每次元素搬动位置都是跳跃式搬动，而不用一位一位的挪动，大量减少搬动次数
  ② 最不断的缩小增量gap（步长）的过程中，其实已经把无序序列排成基本有序，然后当gap=1时，执行最后一次整理，那么也就是对一个基本有序序列进行插入排序，此时插入排序的性能最好

• 时间复杂度：O（n^1.3）~O（n²）

• 空间复杂度：只需要temp一个临时存储空间，所以空间复杂度为O（1）

• n越大，希尔排序效率体现的越明显。

---

4.其他思路：交换插入排序 （Swap Insertion Sort）

• 直接交换插入排序：

void InsertSort(int *r)
{
	int i,j;

	for (i=1;i<Maxsize;i++)

		for(j=i-1;j>=0&&r[j]>r[j+1];j--)

			Swap(r[j],r[j+1]);
}

• 希尔交换插入排序：

void ShellSort(int *r)
{
	int i,j,gap;

	for(gap=n/2;gap>0;gap=gap/2)

		for(i=gap;i<Maxsize;i++)

			for(j=i-gap;j>=0&&r[j]>r[j+gap];j=j-gap)

				Swap(r[j],r[j+gap]);
}				

• 在这种思路下，我们更容易看出直接插入排序与希尔排序的同异之处：
  ① 直接插入排序移动到步长是1，也就是说每次前进一个单位。
  ② 而希尔排序，移动的步长是gap ≥ 1，所以希尔排序前进的更快！

---

参考：

1. MoreWindows白话经典算法之七大排序——插入排序
2. MoreWindows白话经典算法之七大排序——希尔排序
3. 原来「插入排序」面试官爱考是因为这样~~