之前通过递归实现了 最终排序，但依然需要优化

优化的原因如下：

1、对于key值的选取，仅以最左边作为key值，可能会导致栈溢出

2、递归的时候，如果区间长度小于10（10 只是一个参考值），使用快排的效率不高

优化一：避免key出现在边界

这里使用的方法是三数取中法

三数：最左边的数、数组中间位置的数、最右边的数

比较三个数的大小，取中位数作为key

int GetMid(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	if (a[left]>a[right])
	{
		if (a[left]<a[mid])
		{
			return left;
		}
		else
		{
			return a[right] > a[mid] ? right : mid;
		}
	}
	else
	{
		if (a[right] < a[mid])
		{
			return right;
		}
		else
		{
			return a[left] > a[mid] ? left : mid;
		}
	}
}

在单趟排序中，拿到key的下标以后，把key换到最左边，这样就不会影响后面的排序

数据量比较小，优化的效果不是特别明显

优化二：数据个数小于10 的时候，使用直接插入排序

问：为什么不用希尔排序？

答：希尔排序可以用，但有点杀鸡用牛刀的感觉，数据量较大的时候，使用希尔排序合适

问：为什么不用堆排序？

答：堆排序建堆比较麻烦，建完还要自上而下调整，步骤比较繁琐

//稍微调整一下插入排序
void InsertSort(int* a,int left,int right)
{
	int size = right - left + 1;
	for (size_t i = left; i < size-1; i++)
	{
		int end = i;
		int val = a[end + 1];
		while (end >= 0)
		{
			if (a[end] > val)
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}

			p++;
		}
		a[end + 1] = val;
	}
}

void RecurseSort(int* a,int left,int right)
{
	//分解到最后的结束条件是left >= right
	if (left >= right)
	{
		return;
	}

	if (right-left+1 <= 5)
	{
		InsertSort(a, left, right);
	}
	else
	{
		//单趟排序，选定key值，比key小的放左边，比key大的放右边，返回分界点下标keyi
		int keyi = SingleSort(a, left, right);
		//单趟排完以后，开始向左递归分解，区间范围是 [left , keyi-1]
		RecurseSort(a, left, keyi - 1);
        //向右递归分解，区间范围是 [keyi + 1 , right]
		RecurseSort(a, keyi + 1, right);
	}
}