【排序一】插入排序（直接插入排序&&希尔排序）

注意：以下所有代码测试环境均为VS2010，并且代码只提供核心部分，部分头文件和主函数由阅读者自行添加测试

一、排序的分类

由于排序内容比较多，为了防止混淆，此篇文章就只对插入排序的两个算法进行分析，其他排序后序讲解……

二、直接插入排序

1、基本思想：

       将需要排序的有限序列看做两个小区间，第一个区间为已经排好序的有序序列，第二个区间为无序序列，每次从无序区间拿出一个数据放入有序区间的合适位置，直到第二个区间无数据，则排序完成。

  图解（假设为升序）：

2、算法执行步骤：

1）从第一个元素开始，该元素可以认为已经被排序

2）取出下一个元素，在已经排序的元素序列中从后向前扫描

3）如果该元素（已排序）大于新元素，将该元素移到下一位置

4）重复步骤3），直到找到已排序的元素小于或者等于新元素的位置

5）将新元素插入到该位置中

6）重复步骤2）

3、时间复杂度&&空间复杂度

 如果目标是把n个元素的序列按升序排列，那么采用插入排序存在最好情况和最坏情况。

最好情况就是，序列已经是升序排列了，在这种情况下，需要进行的比较操作需(n-1)次即可。

最坏情况就是，序列是降序排列，那么此时需要进行的比较共有n(n-1)/2次。

插入排序的赋值操作是比较操作的次数减去(n-1)次。平均来说插入排序算法复杂度为O(n²)。因而，插入排序不适合对于数据量比较大的排序应用。但是，如果需要排序的数据量很小，例如，量级小于千，那么插入排序还是一个不错的选择。

由于算法需要存储的是有限个数据的存储空间，故此插入排序的空间复杂度为O(1)。

4、代码实现

#pragma  once
#include <assert.h>

//用仿函数同时实现升序降序功能
template <class T>
struct  Less//升序
{
	bool operator()(const T& l,const T& r)
	{
		return l < r;
	}
};
template <class T>
struct  Greater//降序
{
	bool operator()(const T& l,const T& r)
	{
		return l > r;
	}
};

template <class T>
void PrintArray(const T* a,size_t n)//打印数组
{
	for (size_t i = 0; i < n; ++i)
	{
		cout<<a[i]<<" ";
	}
	cout<<endl;
}

template <class T ,class Compare>
void InsertSort(T* a,size_t n)
{
	assert(a);

	for (size_t i = 1; i < n; ++i)
	{
		int end = i-1;//有序区间的最后一个下标
		T tmp = a[i];//用临时变量保存无序区间的第一个数据，也是即将插入有序区间的数

		while(end >= 0)
		{
			if (Compare()(tmp,a[end]))//利用仿函数实现比较器
			{
				a[end+1] = a[end];//为tmp挪出合适的位置插入
				--end;
			}
			else
			{
				break;
			}
		}
		a[end+1] = tmp;//将tmp插入有序区间的合适位置
	}
}

void TestInsertSort()
{
	int a[] = {2,5,4,9,3,6,8,7,1,0};
	size_t sz = sizeof(a)/sizeof(a[0]);

	InsertSort<int,Less<int>>(a,sz);//升序测试
	PrintArray(a,sz);
	InsertSort<int,Greater<int>>(a,sz);//降序测试
	PrintArray(a,sz);
}

运行结果：

三、希尔排序（递减增量排序算法）

1、基本思想

     从本质上来讲，希尔排序实际上是对直接插入排序的一种优化，为了防止以上直接插入排序出现最坏情况影响算法效率，希尔排序对其进行了改进，在对数据进行直接排序之前，先对数据进行预排序，使之接近有序，然后再利用直接插入排序对数据进行快速排序。

     总的来说，希尔排序是基于插入排序的以下两点性质而提出改进方法的：

1）插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率

2）但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。

基本思想：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。

图解（假设为升序）：

2、排序效果图

3、时间复杂度&&空间复杂度

分析类似上述直接插入排序，O(N)<希尔排序的时间复杂度<O(N^2),希尔排序，当N大时，平均的时间复杂度，大约在N^1.25--1.6N^1.25之间。

希尔排序的空间复杂度为O(1)。

4、实现代码

#pragma  once
#include <assert.h>

//用仿函数同时实现升序降序功能
template <class T>
struct  Less//升序
{
	bool operator()(const T& l,const T& r)
	{
		return l < r;
	}
};
template <class T>
struct  Greater//降序
{
	bool operator()(const T& l,const T& r)
	{
		return l > r;
	}
};

template <class T>
void PrintArray(const T* a,size_t n)//打印数组
{
	for (size_t i = 0; i < n; ++i)
	{
		cout<<a[i]<<" ";
	}
	cout<<endl;
}

template <class T ,class Compare>
void ShellSort(T* a,size_t n)//希尔排序
{
	assert(a);
	int gap = n;//gap为所给增量
	while(gap > 1)
	{
		//实验证明，gap=gap/3是比较优的，+1则是为了最后一次对全体数据进行插入排序
		gap = gap/3 + 1;
		for (size_t i = gap; i < n; ++i)
		{
			int end = i - gap;
			T tmp = a[i];

			while(end >= 0)
			{
				if (Compare()(tmp,a[end]))
				{
					a[end+gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end+gap] = tmp;
		}
	}
}

void TestShellSort()
{
	int a[] = {2,5,4,9,3,6,8,7,1,0};
	size_t sz = sizeof(a)/sizeof(a[0]);

	ShellSort<int,Less<int>>(a,sz);
	PrintArray(a,sz);
	ShellSort<int,Greater<int>>(a,sz);
	PrintArray(a,sz);
}

运行结果：