三种改进型排序算法-快速排序，堆排序，希尔排序

    快速排序，堆排序，希尔排序这三种算法是从三种基本排序算法-冒泡排序，选择排序，插入排序改良过来的，效率更高。

    快速排序思想：通过一躺排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一不部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

    快速排序代码及注释如下：

 

int Partition(int src[], int low, int high)			//将数组一分为二，算出枢轴值pivotkey
{
	int pivotkey;
	pivotkey = src[low];				//把数组的第一个元素作为枢轴值
	while (low < high)					//从数组的两边交替向中间进行扫描
	{
		while (low < high&&src[high] >= pivotkey)	//找到比枢轴值大的元素
			high--;
		swap(src[low], src[high]);			//进行交换，把大的值放到右边
		while (low < high&&src[low] <= pivotkey)	//找到比枢轴值小的元素
			low++;
		swap(src[low], src[high]);			//进行交换，把小的值放到左边
	}
	return low;					//返回键值所在下标
}

void QuickSort(int src[], int low, int high)			//对数组进行递归排序
{
	int Pivot;
	if (low < high)
	{
		Pivot = Partition(src, low, high);		//将数组一分为二，算出枢轴值pivotkey
		QuickSort(src, low, Pivot - 1);		//对低数组进行递归排序
		QuickSort(src, Pivot + 1, high);		//对高数组进行递归排序
	}
}

堆排序思想：构建大顶堆或小顶堆，以大顶堆为例，每次取根节点的值放在数组末尾，然后再进行堆排序，再取值，达到排序的效果。

堆排序代码及注释如下：

void HeapRebuild(int src[], int root, int size)		//递归构建大顶堆
{
	int LeftChild = 2 * root + 1;			//定义左孩子
	if (LeftChild <= size - 1)				//若具有右孩子，则进行右孩子的判断
	{
		int RightChild = LeftChild + 1;		//在具有右孩子的前提下定义右孩子
		/*如果右孩子之后还有节点，而且左孩子的值比右孩子的值小，则把左孩子置为右孩子*/
		if (RightChild <= size - 1)			
		{
			if (src[LeftChild] < src[RightChild])
			{
				LeftChild = RightChild;
			}
		}
		/*把根节点与左孩子进行比较，如果左孩子值较大，则将其与根节点交换，并递归构建堆*/
		if (src[root]<src[LeftChild])
		{
			swap(src[LeftChild], src[root]);
			HeapRebuild(src, LeftChild, size);
		}
	}
}

void HeapSort(int src[], int len)
{
	for (int i = len - 1; i >= 0; i--)			//从数组尾部开始遍历，进行大顶堆构建
	{
		HeapRebuild(src, i, len);			//递归构建大顶堆
	}
	int last = len - 1;							
	for (int i = 1; i <= len; i++, last--)
	{
		swap(src[0], src[last]);			//因为在上面已经构建好大顶堆，第一个元素为最大值，所以跟最后的元素进行交换
		HeapRebuild(src, 0, last);			//继续构建大顶堆
	}
}

希尔排序思想：先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量  =1(  <  …<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。

希尔排序代码及注释如下：

void ShellSort(int src[], int len)
{
	int i, j, k;
	int temp;
	for (i = len / 2; i > 0; i /= 2)		//增量设置为len/2
	{
		for (j = i; j < len; j++)		//从所设置的增量开始遍历
		{
			temp = src[j];		//先保存当前值
			for (k = j - i; k >= 0 && temp < src[k]; k -= i)	//根据所设置的增量进行跳跃式比较，把较大值全部后移
			{
				src[k + i] = src[k];
			}
			src[k + i] = temp;		//把比较所得的小的值放在前面
		}
	}
}