排序决战！(1)插入排序与希尔排序

在数据结构的学习中，排序是非常重要的算法，今天，我们就来学习插入排序和希尔排序。

排序

概念：

所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次 序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排 序算法是稳定的；否则称为不稳定的。

内部排序：数据元素全部放在内存中的排序。

外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

实际上的排序应用：

 常见的排序算法有这些：冒泡排序、选择排序、插入排序、归并排序、快速排序、希尔排序、堆排序

今天我们集中讲解插入排序和希尔排序

插入排序

1.概念

直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为 止，得到一个新的有序序列 。

我们在现实中也实际上用到了这种排序，比如：打扑克时整理扑克牌就是一种插入排序，如下图

也就是说，如果是升序：逐个把要插入的数据往前比较，前面的数据已经是排好序的了，如果依次比较，比到比前面一张大的，却又比后面小的，就直接插入到第二张前面，

 直接插入排序的特性：

1.元素集合越接近有序，直接插入排序算法的时间效率越高

2. 时间复杂度：O(N^2)

3. 空间复杂度：O(1)，它是一种稳定的排序算法

4. 稳定性：稳定

代码实现

void InsertSort(int* a, int n) {
	//tmp 用来End+1是要插入的位置
	for (int i = 0; i < n - 1; i++)//i记录要走多少次
	{
		int End = i;
		int tmp = a[End + 1];
		while (End >= 0)
		{
			if (tmp < a[End])//升序 比前面的数字小，往前挪动
			{
				a[End + 1] = a[End];
				End--;//往前走
			}
			else//比end大就跳出循环
	  		{
				break;
			}
		}
		a[End + 1] = tmp;//放插入的值，换
	}
}

注意我们在实现代码的时候，要先想实现一轮，再实现整个，从小到大，比如：

在这里 end走到了下标1, tmp(=2)小于a[end](=3)，a[end+1]就往前挪动到a[end]再进行比较，此时a[end+1]就走到了下标为1的时候，end走到了下标0，再进行比较，tmp(=2)比a[end]（=0）大，跳出循环，进行插入a[end+1]=tmp

总的来说，就是如果比前面小就往前挪动，比前面大，停止挪动，直到要排的那个值比前面大，比后面小,就进行插入 。

2.希尔排序

基本思想

 基于插入排序的基础，先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。

希尔排序的特性总结：

1. 希尔排序是对直接插入排序的优化。

2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就 会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。

3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的 希尔排序的时间复杂度都不固定

4.希尔排序的gap有很多取法，例如最初Shell提出的gap=[n/2],gap=[gap/2],也有后面Knuth大佬提出的gap=[gap/3]+1

代码实现

void ShellSort(int* a, int n) {
	int gap =  (n/3)+1;
	while (gap>1)
	{
		gap = (gap / 3) + 1;
		for (int j = 0; j < gap; ++j)
		{
			for (int i = j; i < n - gap; i += gap)
			{
				int end = i;
				int tmp = a[end + gap];
				while (end >= 0)
				{
					if (tmp < a[end])
					{
						a[end + gap] = a[end];
						end -= gap;
					}
					else
					{
						break;
					}
				}
				a[end + gap] = tmp;
			}
		}
	}
}

这个代码是一组一组排序，一组排完排下一组，我们也可以换一种方式，让多组并排

//多组并排
void ShellSort1(int* a, int n) {
	int gap = n;
	while (gap>1)
	{
		 gap = (gap / 3) + 1;
		 for (int i = 0; i < n-gap; i++)
		 {
			 int end = i;
			 int tmp = a[end +gap];//下一个跟上一个比
			 while (end>=0)
			 {
				 if (tmp<a[end])
				 {
					 a[end + gap] = a[end];
					 end -= gap;
				 }
				 else
				 {
					 break;
				 }
			 }
			 a[end + gap] = tmp;
		 }
	}
}

如图 

第一趟排完了，就继续让gap=gap/3+1，继续下面的趟数，继续排序

时间复杂度：希尔排序的时间复杂度比较难以计算，我们就直接取书中内容

《数据结构-用面相对象方法与C++描述》--- 殷人昆：

 

因为咋们的gap是按照Knuth提出的方式取值的，而且Knuth进行了大量的试验统计，我们暂时就按照

                                             O(n^1.25)到O(1.6*n1.25)

决战（测试）：

我们可以给出一个测试用例来计算运行的速度

我们可以写一个创造数组函数来开辟数组

int* numcreate(int n) {
	assert(n);
	int* num = (int*)malloc(sizeof(int) * n);
	return num;
}

接着用rand来赋随机值

void testOP() {
	srand(time(0));
	const int N = 100000;
	int* a1 = numcreate(N);
	int* a2 = numcreate(N);
	int* a3 = numcreate(N);
	for (int i = 0; i < N; ++i)
	{
		a1[i] = rand();
		a2[i] = a1[i];
		a3[i] = a1[i];
	}
	int begin1 = clock();
	InsertSort(a1, N);
	int end1 = clock();

	int begin2 = clock();
	ShellSort1(a2,N);
	int end2 = clock();
	
	int begin3 = clock();
	ShellSort(a3, N);
	int end3 = clock();
	
	printf("Insert: %d\n", end1 - begin1);
	printf("Shell: %d\n", end2 - begin2);
	printf("Shell1: %d\n", end3 - begin3);

}

运行结果

插入排序跟希尔排序比起来还是太逊了 

恭喜希尔在本回合获得大胜利！（揭开他们的面纱~）

 谢谢观看，若文章有不对或者有疑问的地方欢迎在评论区留言哦