排序算法

插入排序的基本思想是每次将一个待排序的记录，按其关键字的大小插入到已经排序好的子序列中，直到全部记录插入完成。插入排序分为了直接插入排序、折半插入排序和希尔排序。

1.直接插入排序

直接插入排序是比较简单粗暴的排序算法之一，算法步骤如下：

1. 把待排序数组分成两部分，长度为1和长度为n-1的子数组，（长度为1的子数组此时已经是排序好的）
2. 从第二个数组中按序拿出一个元素，并插入到第一个子数组的合适位置，使得第一个子数组依然是排好序的
3. 重复步骤2，直至排序完成。

它的代码比较简单，如下：

/**
 * v1.0插入排序
 * @param nums: 待排序数组
 * @param len: 数组的长度
*/
template<class Type>
void insert_sort(Type nums[], int len) {
	for (int j = 1; j < len; j++) {
		Type key = nums[j];
		int i = j - 1;
		
		//为该元素找到一个合适的位置，并插入
		while (i >= 0 && nums[i] > key) {
			nums[i + 1] = nums[i];
			i = i - 1;
		}
		nums[i + 1] = key;
	}
}

 直接插入排序的另一个实现：

/**
 * v1.1插入排序
 * @param nums: 待排序数组
 * @param len: 数组的长度
*/
template<typename T>
void insert_sort(vector<T>& arr)
{
	int i, j;
	for (i = 1; i < arr.size(); i++)
	{
		//待插入数字小于排序子序列的最后一个数据
		if (arr[i] < arr[i - 1])
		{
			arr[0] = arr[i];
			for (j = i - 1; arr[0] < arr[j]; j--)
			{
				arr[j + 1] = arr[j];
			}
			arr[j + 1] = arr[0];
		}
	}
}

 arr[0]作为哨兵，arr[0]不参与排序，除了保存副本外，还可以简化边界，如果arr[0]参与运算，那么代码需改成：

/**
 * v1.2插入排序
 * @param nums: 待排序数组
 * @param len: 数组的长度
*/
template<typename T>
void insert_sort(vector<T>& arr)
{
	int i, j;
	for (i = 1; i < arr.size(); i++)
	{
		//待插入数字小于排序子序列的最后一个数据
		if (arr[i] < arr[i - 1])
		{
            //改动1：暂存数据
			T temp = arr[i];
            //改动2：添加边界条件
			for (j = i - 1; temp < arr[j] && j >= 0; j--)
			{
				arr[j + 1] = arr[j];
			}
			arr[j + 1] = temp;
		}
	}
}

接下来举个简单的例子：

假设待排序数组为{8, 2, 4, 9, 3, 6}
初始分成了{8} {2, 4, 9, 3, 6}
第一次 => {2, 8} {4, 9, 3, 6}
第二次 => {2, 4, 8} {9, 3, 6}
第三次 => {2, 4, 8, 9} {3, 6}
第四次 => {2, 3, 4, 8, 9} {6}
第五次 => {2, 3, 4, 6, 8, 9}
排序完成

代码过程如上例所示，插入排序的最坏时间复杂度为O()。

插入排序的效率在规模小的时候和其他排序差别不大，当排序量较大的情况下，不建议使用。

想测效率的话可以在leetcode排序数组测试，不过应该会超时。。。

2.希尔排序

希尔排序是直接插入排序的改进。直接插入排序选用1作为步长，而希尔排序选中d作为步长(d=n/2, ...)，代码如下：

/**
 * v2.2插入排序
 * @param nums: 待排序数组
 * @param len: 数组的长度
*/
template<class T>
void shell_sort(vector<T>& arr)
{
	int dk, i, j;
	//步长
	for (dk = arr.size() / 2; dk >= 1; dk /= 2)
	{
		for (i = dk + 1; i < arr.size(); i++)
		{
			if (arr[i] < arr[i - dk])
			{
				T temp = arr[i];
				for (j = i - dk; temp < arr[j] && j >= 0; j-=dk)
				{
					arr[j + dk] = arr[j];
				}
				arr[j + dk] = temp;
			}
		}
	}
}

 希尔排序跳着进行排序，最后一次排序时，步长为0，希尔排序使用直接插入进行排序。希尔排序平均时间复杂度约为，最坏时间复杂度为。

3.选择排序

选择排序的时间复杂度是，适用于小数据量，算法步骤如下：

1. 在未排序数列中找到一个最小值的索引，存放到排序序列的起始位置；
2. 再冲剩余未排序序列中选择一个最小值，放到已排序序列的末尾；
3. 重复步骤2，直至索引的排序均已完成。

 举例，如下：

假设待排序数组为{8, 2, 4, 9, 3, 6}

第一次 {2} {8, 4, 9, 3, 6}
第二次 {2, 3} {8, 4, 9, 6}
第三次 {2, 3, 4} {6, 8, 9}
第四次 {2, 3, 4, 6} {8, 9}
第五次 {2, 3, 4, 6, 8} {9}
第六次 {2, 3, 4, 6, 8, 9}

排序完成

 c++代码如下：

template<typename T>
void selection_sort(vector<T>& arr)
{
	for (int i = 0; i < arr.size(); i++)
	{
		int min = i;
		for (int j = i + 1; j < arr.size(); j++)
		{
			if (arr[j] < arr[min])
				min = j;
		}
		std::swap(arr[i], arr[min]);
	}
}

其他算法：

1. 快速排序
2. 合并排序

4.总结 

在leetcode上的统一测试下：

快速排序的随机版是最快的，大概88ms左右；其次是自然合并排序，大概96ms左右；其他的几个则相差了几个毫秒不等。