插入排序 与 希尔排序

1 排序

1.1排序的概念

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
排序存在稳定性，稳定性是评估排序的重要标准。
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
排序可以概括为两大类 、六大排序：
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

这篇文章我们先介绍插入排序。

2 插入排序

2.1 插入排序原理

生活中最常见的插入排序就是扑克牌，我们一张一张的拿出来，比较然后放在合适位置。所用思想就是插入排序：
把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。

2.2 排序步骤

1. 从第一个元素开始，默认已经有序
2. 取后一个元素tmp ，开始向前扫描
3. (升序)如果有序序列的最后一个元素大于tmp , 有序序列结尾下标向前移动
4. 重复 3 步骤，直到有序序列最后一个元素小于tmp
5. 插入tmp在该有序序列后。
6. 再取数组下一个元素，重复 1-5 步骤
   

2.3 代码实现

// 插入排序
void InsertSort(int* a, int n) {for (int i = 0; i < n - 1; i++) {int end = i;//记录有序部分的最后下标int tmp = a[end + 1];//被排序数while (end >= 0) {if (a[end] > tmp) {//如果有序部分最大值大于被排序数，有序下标--a[end + 1] = a[end];end--;}else//如果有序部分最大值小于被排序数，直接退出。break;}//在比被排序数小的有序部分后赋值a[end + 1] = tmp;}
}

功能实现效果，非常nice。

直接插入排序的特性总结：

1. 元素集合越接近有序，直接插入排序算法的时间效率越高。
2. 时间复杂度：O(N^2) 。
3. 空间复杂度：O(1)，它是一种稳定的排序算法
4. 稳定性：稳定

3 希尔排序

3.1 希尔排序原理

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。

根据插入排序的特性 元素集合越接近有序，直接插入排序算法的时间效率越高。，我们进行多次不同gap的插入排序，使其逐渐有序。进而时间复杂度更低。
插入排序可以视为特殊的希尔排序。

3.2 排序步骤

1. 选定gap值，并分组进行预排序
2. 每组进行插入排序，使序列变得更加有序。
3. gap值变小（务必保证最后一次是gap==1）
4. 重复 1 - 3 步骤，直到gap为1。
5. 排序完成。
   

3.3 代码实现

// 希尔排序
void ShellSort(int* a, int n) {int gap = n;//设置初始gap值while (gap > 1) {gap = gap / 2;//每次除2 直至为 1for (int i = 0; i < n - gap; i++) {//每组插入排序int end = i;int tmp = a[end + gap];while (end >= 0) {if (a[end] > tmp) {a[end + gap] = a[end];end -= gap;}elsebreak;}a[end + gap] = tmp;//结束后赋值}}
}

运行查看效果，very good！

希尔排序的特性总结：

1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就
   会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的
   希尔排序的时间复杂度都不固定：

4 时间复杂度分析

我们设计一个100000个数据测试函数，来检测一下插入排序，希尔排序的时间复杂度（以冒泡排序为对照组）。
请看下面测试效果：

这里希尔排序有非常明显的优势，运算非常之快，其次为插入排序。普通的冒泡排序在这里就像蝼蚁一般。

至于希尔排序的时间复杂度目前还没有证明。大概为n^1.3。下面是殷老师的观点。

Thanks♪(･ω･)ﾉ

下一篇文章见！！！！！！！