排序算法总结（2）：快速排序，归并排序，堆排序

一、快速排序

基本流程：如图，将序列4 3 8 6 7 1 2 9进行一趟快速排序，：

 代码实现：

//快速排序
int Partition(int R[], int low, int high)//low为第一个元素位置，high为最后一个元素位置
{
	int temp = R[low];//第一个元素为中间值
	while (low < high)
	{
		while (R[high] >= temp && low < high)//右边的指针向左移，直到遇到比中间值小的元素x
			high--;
		if (low < high)//把x赋给左边指针的元素
			R[low] = R[high];

		while (R[low] <= temp && low < high)//左边的指针向右移移，直到遇到比中间值大的元素y
			low++;
		if (low < high)//把y赋给右边指针的元素
			R[high] = R[low];
	}
	R[low] = temp;	//两边指针相遇，把中间值赋给指针指向的元素
	return low;
}
void QuickSort(int R[], int s, int t)
{
	int m;
	if (s < t)
	{
		m = Partition(R, s, t);
		QuickSort(R, m+1, t);
		QuickSort(R, s, m-1);
	}
}

二、归并排序

①将两个有序的序列合并成一个有序的序列

②用递归的思想，把一个无序序列二分地拆开，然后再排序合并。

代码实现：

//归并排序
void Merge(int S[], int T[], int i, int m, int n)
//数组S中i-m是有序的，m+1是有序的，排序放入数组T.
{
	int j, k;
	for (j = m + 1, k = i; i <= m && j <= n; k++)
	//i,j分别指向两个数组，然后选两者中小的放入T数组并将指针向后移动。
	{
		if (S[i] <= S[j])
			T[k] = S[i++];
		else
			T[k] = S[j++];
	}
	//将剩余的数组的元素放入T数组。
	while (i <= m)
		T[k++] = S[i++];
	while (j <= n)
		T[k++] = S[j++];
}

void MSort(int R[], int T[], int s, int t)
{
	int* p = new int[t - s + 1];
	int m;
	if (s == t)T[s] = R[s];
	else
	{
		m = (s + t) / 2;
		MSort(R, p, s, m);
		MSort(R, p, m + 1, t);
		Merge(p, T, s, m, t);
	}
}

三、堆排序

初始化大根堆需要理解一下，剩余的步骤就是做大根堆，然后堆顶与堆底互换，最大的放在最后面。

代码实现：

//堆排序
void HeapAdjust(int H[], int s, int m)//将数组的s-m进行大顶堆的排
{
	int temp = H[s];//暂存根节点
	for (int j = 2 * s; j <= m; j *= 2)
	{
		if (j < m && H[j] < H[j + 1])j++;//左右孩子中选较大的那个
		if (temp >= H[j]) break;//根节点最大就退出
		int t;
		t = H[s];//将孩子与父结点互换
		H[s] = H[j];
		H[j] = t;
		s = j;//孩子成为下一个父结点
	}

}
void HeapSort(int H[], int n)
{
	int temp;
	for (int i = n / 2; i > 0; i--)//初始化大根堆
		HeapAdjust(H, i, n);
	temp = H[1];//交换堆顶与堆底
	H[1] = H[n];
	H[n] = temp;
	for (int i = n - 1; i > 1; i--)//从根开始调整，重新调整为大顶堆
	{
		HeapAdjust(H, 1, i);
		temp = H[1];
		H[1] = H[i];
		H[i] = temp;	
	}
}